#include <bits/stdc++.h>
using namespace std;
int oo = 1000000000;
int cl[100100];
int op[100100];
string s;
int dp_min[10101][101];
int dp_max[10101][101];
int solvePmin(int pos, int cnt);
int solvePmax(int pos, int cnt);
int solveMmin(int pos, int cnt);
int solveMmax(int pos, int cnt);
int getval(int idx) { return (s[idx] - '0'); }
int solvePmin(int pos, int cnt) {
  if (cnt < 0) {
    return oo;
  }
  int end = cl[pos];
  int dist = end - pos;
  int signs = dist / 4;
  if (signs < cnt) {
    return oo;
  }
  if (dp_min[pos][cnt] != oo) {
    return dp_min[pos][cnt];
  }
  if (dist == 4) {
    if (cnt == 0) {
      return dp_min[pos][cnt] = getval(pos + 1) - getval(pos + 3);
    } else {
      return dp_min[pos][cnt] = getval(pos + 1) + getval(pos + 3);
    }
  }
  int l1, r1, l2, r2;
  if (s[pos + 1] == '(') {
    l1 = pos + 1;
    r1 = cl[l1];
  } else {
    l1 = pos + 1;
    r1 = pos + 1;
  }
  if (s[end - 1] == ')') {
    r2 = end - 1;
    l2 = op[r2];
  } else {
    l2 = end - 1;
    r2 = end - 1;
  }
  if (l1 == r1) {
    int res = oo;
    res = min(res, getval(pos + 1) + solvePmin(l2, cnt - 1));
    res = min(res, getval(pos + 1) - solvePmax(l2, cnt));
    return dp_min[pos][cnt] = res;
  }
  if (l2 == r2) {
    int res = oo;
    res = min(res, solvePmin(l1, cnt - 1) + getval(l2));
    res = min(res, solvePmin(l1, cnt) - getval(l2));
    return dp_min[pos][cnt] = res;
  }
  int res = oo;
  for (int i = 0; i <= cnt; i++) {
    res = min(res, solvePmin(l1, i) + solvePmin(l2, cnt - i - 1));
    res = min(res, solvePmin(l1, i) - solvePmax(l2, cnt - i));
  }
  return dp_min[pos][cnt] = res;
}
int solvePmax(int pos, int cnt) {
  if (cnt < 0) {
    return -oo;
  }
  int end = cl[pos];
  int dist = end - pos;
  int signs = dist / 4;
  if (signs < cnt) {
    return -oo;
  }
  if (dp_max[pos][cnt] != -oo) {
    return dp_max[pos][cnt];
  }
  if (dist == 4) {
    if (cnt == 0) {
      return dp_max[pos][cnt] = getval(pos + 1) - getval(pos + 3);
    } else {
      return dp_max[pos][cnt] = getval(pos + 1) + getval(pos + 3);
    }
  }
  int l1, r1, l2, r2;
  if (s[pos + 1] == '(') {
    l1 = pos + 1;
    r1 = cl[l1];
  } else {
    l1 = pos + 1;
    r1 = pos + 1;
  }
  if (s[end - 1] == ')') {
    r2 = end - 1;
    l2 = op[r2];
  } else {
    l2 = end - 1;
    r2 = end - 1;
  }
  if (l1 == r1) {
    int res = -oo;
    res = max(res, getval(pos + 1) + solvePmax(l2, cnt - 1));
    res = max(res, getval(pos + 1) - solvePmin(l2, cnt));
    return dp_max[pos][cnt] = res;
  }
  if (l2 == r2) {
    int res = -oo;
    res = max(res, solvePmax(l1, cnt - 1) + getval(l2));
    res = max(res, solvePmax(l1, cnt) - getval(l2));
    return dp_max[pos][cnt] = res;
  }
  int res = -oo;
  for (int i = 0; i <= cnt; i++) {
    res = max(res, solvePmax(l1, i) + solvePmax(l2, cnt - i - 1));
    res = max(res, solvePmax(l1, i) - solvePmin(l2, cnt - i));
  }
  return dp_max[pos][cnt] = res;
}
int solveMmin(int pos, int cnt) {
  if (cnt < 0) {
    return oo;
  }
  int end = cl[pos];
  int dist = end - pos;
  int signs = dist / 4;
  if (signs < cnt) {
    return oo;
  }
  if (dp_min[pos][cnt] != oo) {
    return dp_min[pos][cnt];
  }
  if (dist == 4) {
    if (cnt == 1) {
      return dp_min[pos][cnt] = getval(pos + 1) - getval(pos + 3);
    } else {
      return dp_min[pos][cnt] = getval(pos + 1) + getval(pos + 3);
    }
  }
  int l1, r1, l2, r2;
  if (s[pos + 1] == '(') {
    l1 = pos + 1;
    r1 = cl[l1];
  } else {
    l1 = pos + 1;
    r1 = pos + 1;
  }
  if (s[end - 1] == ')') {
    r2 = end - 1;
    l2 = op[r2];
  } else {
    l2 = end - 1;
    r2 = end - 1;
  }
  if (l1 == r1) {
    int res = oo;
    res = min(res, getval(pos + 1) + solveMmin(l2, cnt));
    res = min(res, getval(pos + 1) - solveMmax(l2, cnt - 1));
    return dp_min[pos][cnt] = res;
  }
  if (l2 == r2) {
    int res = oo;
    res = min(res, solveMmin(l1, cnt) + getval(l2));
    res = min(res, solveMmin(l1, cnt - 1) - getval(l2));
    return dp_min[pos][cnt] = res;
  }
  int res = oo;
  for (int i = 0; i <= cnt; i++) {
    res = min(res, solveMmin(l1, i) + solveMmin(l2, cnt - i));
    res = min(res, solveMmin(l1, i) - solveMmax(l2, cnt - i - 1));
  }
  return dp_min[pos][cnt] = res;
}
int solveMmax(int pos, int cnt) {
  if (cnt < 0) {
    return -oo;
  }
  int end = cl[pos];
  int dist = end - pos;
  int signs = dist / 4;
  if (signs < cnt) {
    return -oo;
  }
  if (dp_max[pos][cnt] != -oo) {
    return dp_max[pos][cnt];
  }
  if (dist == 4) {
    if (cnt == 1) {
      return dp_max[pos][cnt] = getval(pos + 1) - getval(pos + 3);
    } else {
      return dp_max[pos][cnt] = getval(pos + 1) + getval(pos + 3);
    }
  }
  int l1, r1, l2, r2;
  if (s[pos + 1] == '(') {
    l1 = pos + 1;
    r1 = cl[l1];
  } else {
    l1 = pos + 1;
    r1 = pos + 1;
  }
  if (s[end - 1] == ')') {
    r2 = end - 1;
    l2 = op[r2];
  } else {
    l2 = end - 1;
    r2 = end - 1;
  }
  if (l1 == r1) {
    int res = -oo;
    res = max(res, getval(pos + 1) + solveMmax(l2, cnt));
    res = max(res, getval(pos + 1) - solveMmin(l2, cnt - 1));
    return dp_max[pos][cnt] = res;
  }
  if (l2 == r2) {
    int res = -oo;
    res = max(res, solveMmax(l1, cnt) + getval(l2));
    res = max(res, solveMmax(l1, cnt - 1) - getval(l2));
    return dp_max[pos][cnt] = res;
  }
  int res = -oo;
  for (int i = 0; i <= cnt; i++) {
    res = max(res, solveMmax(l1, i) + solveMmax(l2, cnt - i));
    res = max(res, solveMmax(l1, i) - solveMmin(l2, cnt - i - 1));
  }
  return dp_max[pos][cnt] = res;
}
int main() {
  for (int i = 0; i < 10101; i++) {
    for (int j = 0; j < 101; j++) {
      dp_min[i][j] = oo;
      dp_max[i][j] = -oo;
    }
  }
  cin >> s;
  if ((int)(s).size() == 1) {
    cout << s << endl;
    return 0;
  }
  vector<int> stack;
  for (int i = 0; i < (int)(s).size(); i++) {
    if (s[i] == '(') {
      stack.push_back(i);
    } else if (s[i] == ')') {
      int idx = stack.back();
      stack.pop_back();
      cl[idx] = i;
      op[i] = idx;
    }
  }
  int P, M;
  scanf("%d %d", &P, &M);
  if (P <= M) {
    cout << solvePmax(0, P);
  } else {
    cout << solveMmax(0, M);
  }
  return 0;
}

### Prompt

Develop a solution in CPP to the problem described below:

Ancient Egyptians are known to have understood difficult concepts in mathematics. The ancient Egyptian mathematician Ahmes liked to write a kind of arithmetic expressions on papyrus paper which he called as Ahmes arithmetic expression.

An Ahmes arithmetic expression can be defined as: 

  * "d" is an Ahmes arithmetic expression, where d is a one-digit positive integer; 
  * "(E1 op E2)" is an Ahmes arithmetic expression, where E1 and E2 are valid Ahmes arithmetic expressions (without spaces) and op is either plus ( + ) or minus ( - ). 

For example 5, (1-1) and ((1+(2-3))-5) are valid Ahmes arithmetic expressions.

On his trip to Egypt, Fafa found a piece of papyrus paper having one of these Ahmes arithmetic expressions written on it. Being very ancient, the papyrus piece was very worn out. As a result, all the operators were erased, keeping only the numbers and the brackets. Since Fafa loves mathematics, he decided to challenge himself with the following task:

Given the number of plus and minus operators in the original expression, find out the maximum possible value for the expression on the papyrus paper after putting the plus and minus operators in the place of the original erased operators.

Input

The first line contains a string E (1 ≤ |E| ≤ 104) — a valid Ahmes arithmetic expression. All operators are erased and replaced with '?'.

The second line contains two space-separated integers P and M (0 ≤ min(P, M) ≤ 100) — the number of plus and minus operators, respectively. 

It is guaranteed that P + M =  the number of erased operators.

Output

Print one line containing the answer to the problem.

Examples

Input

(1?1)
1 0


Output

2


Input

(2?(1?2))
1 1


Output

1


Input

((1?(5?7))?((6?2)?7))
3 2


Output

18


Input

((1?(5?7))?((6?2)?7))
2 3


Output

16

Note

  * The first sample will be (1 + 1) = 2. 
  * The second sample will be (2 + (1 - 2)) = 1. 
  * The third sample will be ((1 - (5 - 7)) + ((6 + 2) + 7)) = 18. 
  * The fourth sample will be ((1 + (5 + 7)) - ((6 - 2) - 7)) = 16. 

### Response

```cpp
#include <bits/stdc++.h>
using namespace std;
int oo = 1000000000;
int cl[100100];
int op[100100];
string s;
int dp_min[10101][101];
int dp_max[10101][101];
int solvePmin(int pos, int cnt);
int solvePmax(int pos, int cnt);
int solveMmin(int pos, int cnt);
int solveMmax(int pos, int cnt);
int getval(int idx) { return (s[idx] - '0'); }
int solvePmin(int pos, int cnt) {
  if (cnt < 0) {
    return oo;
  }
  int end = cl[pos];
  int dist = end - pos;
  int signs = dist / 4;
  if (signs < cnt) {
    return oo;
  }
  if (dp_min[pos][cnt] != oo) {
    return dp_min[pos][cnt];
  }
  if (dist == 4) {
    if (cnt == 0) {
      return dp_min[pos][cnt] = getval(pos + 1) - getval(pos + 3);
    } else {
      return dp_min[pos][cnt] = getval(pos + 1) + getval(pos + 3);
    }
  }
  int l1, r1, l2, r2;
  if (s[pos + 1] == '(') {
    l1 = pos + 1;
    r1 = cl[l1];
  } else {
    l1 = pos + 1;
    r1 = pos + 1;
  }
  if (s[end - 1] == ')') {
    r2 = end - 1;
    l2 = op[r2];
  } else {
    l2 = end - 1;
    r2 = end - 1;
  }
  if (l1 == r1) {
    int res = oo;
    res = min(res, getval(pos + 1) + solvePmin(l2, cnt - 1));
    res = min(res, getval(pos + 1) - solvePmax(l2, cnt));
    return dp_min[pos][cnt] = res;
  }
  if (l2 == r2) {
    int res = oo;
    res = min(res, solvePmin(l1, cnt - 1) + getval(l2));
    res = min(res, solvePmin(l1, cnt) - getval(l2));
    return dp_min[pos][cnt] = res;
  }
  int res = oo;
  for (int i = 0; i <= cnt; i++) {
    res = min(res, solvePmin(l1, i) + solvePmin(l2, cnt - i - 1));
    res = min(res, solvePmin(l1, i) - solvePmax(l2, cnt - i));
  }
  return dp_min[pos][cnt] = res;
}
int solvePmax(int pos, int cnt) {
  if (cnt < 0) {
    return -oo;
  }
  int end = cl[pos];
  int dist = end - pos;
  int signs = dist / 4;
  if (signs < cnt) {
    return -oo;
  }
  if (dp_max[pos][cnt] != -oo) {
    return dp_max[pos][cnt];
  }
  if (dist == 4) {
    if (cnt == 0) {
      return dp_max[pos][cnt] = getval(pos + 1) - getval(pos + 3);
    } else {
      return dp_max[pos][cnt] = getval(pos + 1) + getval(pos + 3);
    }
  }
  int l1, r1, l2, r2;
  if (s[pos + 1] == '(') {
    l1 = pos + 1;
    r1 = cl[l1];
  } else {
    l1 = pos + 1;
    r1 = pos + 1;
  }
  if (s[end - 1] == ')') {
    r2 = end - 1;
    l2 = op[r2];
  } else {
    l2 = end - 1;
    r2 = end - 1;
  }
  if (l1 == r1) {
    int res = -oo;
    res = max(res, getval(pos + 1) + solvePmax(l2, cnt - 1));
    res = max(res, getval(pos + 1) - solvePmin(l2, cnt));
    return dp_max[pos][cnt] = res;
  }
  if (l2 == r2) {
    int res = -oo;
    res = max(res, solvePmax(l1, cnt - 1) + getval(l2));
    res = max(res, solvePmax(l1, cnt) - getval(l2));
    return dp_max[pos][cnt] = res;
  }
  int res = -oo;
  for (int i = 0; i <= cnt; i++) {
    res = max(res, solvePmax(l1, i) + solvePmax(l2, cnt - i - 1));
    res = max(res, solvePmax(l1, i) - solvePmin(l2, cnt - i));
  }
  return dp_max[pos][cnt] = res;
}
int solveMmin(int pos, int cnt) {
  if (cnt < 0) {
    return oo;
  }
  int end = cl[pos];
  int dist = end - pos;
  int signs = dist / 4;
  if (signs < cnt) {
    return oo;
  }
  if (dp_min[pos][cnt] != oo) {
    return dp_min[pos][cnt];
  }
  if (dist == 4) {
    if (cnt == 1) {
      return dp_min[pos][cnt] = getval(pos + 1) - getval(pos + 3);
    } else {
      return dp_min[pos][cnt] = getval(pos + 1) + getval(pos + 3);
    }
  }
  int l1, r1, l2, r2;
  if (s[pos + 1] == '(') {
    l1 = pos + 1;
    r1 = cl[l1];
  } else {
    l1 = pos + 1;
    r1 = pos + 1;
  }
  if (s[end - 1] == ')') {
    r2 = end - 1;
    l2 = op[r2];
  } else {
    l2 = end - 1;
    r2 = end - 1;
  }
  if (l1 == r1) {
    int res = oo;
    res = min(res, getval(pos + 1) + solveMmin(l2, cnt));
    res = min(res, getval(pos + 1) - solveMmax(l2, cnt - 1));
    return dp_min[pos][cnt] = res;
  }
  if (l2 == r2) {
    int res = oo;
    res = min(res, solveMmin(l1, cnt) + getval(l2));
    res = min(res, solveMmin(l1, cnt - 1) - getval(l2));
    return dp_min[pos][cnt] = res;
  }
  int res = oo;
  for (int i = 0; i <= cnt; i++) {
    res = min(res, solveMmin(l1, i) + solveMmin(l2, cnt - i));
    res = min(res, solveMmin(l1, i) - solveMmax(l2, cnt - i - 1));
  }
  return dp_min[pos][cnt] = res;
}
int solveMmax(int pos, int cnt) {
  if (cnt < 0) {
    return -oo;
  }
  int end = cl[pos];
  int dist = end - pos;
  int signs = dist / 4;
  if (signs < cnt) {
    return -oo;
  }
  if (dp_max[pos][cnt] != -oo) {
    return dp_max[pos][cnt];
  }
  if (dist == 4) {
    if (cnt == 1) {
      return dp_max[pos][cnt] = getval(pos + 1) - getval(pos + 3);
    } else {
      return dp_max[pos][cnt] = getval(pos + 1) + getval(pos + 3);
    }
  }
  int l1, r1, l2, r2;
  if (s[pos + 1] == '(') {
    l1 = pos + 1;
    r1 = cl[l1];
  } else {
    l1 = pos + 1;
    r1 = pos + 1;
  }
  if (s[end - 1] == ')') {
    r2 = end - 1;
    l2 = op[r2];
  } else {
    l2 = end - 1;
    r2 = end - 1;
  }
  if (l1 == r1) {
    int res = -oo;
    res = max(res, getval(pos + 1) + solveMmax(l2, cnt));
    res = max(res, getval(pos + 1) - solveMmin(l2, cnt - 1));
    return dp_max[pos][cnt] = res;
  }
  if (l2 == r2) {
    int res = -oo;
    res = max(res, solveMmax(l1, cnt) + getval(l2));
    res = max(res, solveMmax(l1, cnt - 1) - getval(l2));
    return dp_max[pos][cnt] = res;
  }
  int res = -oo;
  for (int i = 0; i <= cnt; i++) {
    res = max(res, solveMmax(l1, i) + solveMmax(l2, cnt - i));
    res = max(res, solveMmax(l1, i) - solveMmin(l2, cnt - i - 1));
  }
  return dp_max[pos][cnt] = res;
}
int main() {
  for (int i = 0; i < 10101; i++) {
    for (int j = 0; j < 101; j++) {
      dp_min[i][j] = oo;
      dp_max[i][j] = -oo;
    }
  }
  cin >> s;
  if ((int)(s).size() == 1) {
    cout << s << endl;
    return 0;
  }
  vector<int> stack;
  for (int i = 0; i < (int)(s).size(); i++) {
    if (s[i] == '(') {
      stack.push_back(i);
    } else if (s[i] == ')') {
      int idx = stack.back();
      stack.pop_back();
      cl[idx] = i;
      op[i] = idx;
    }
  }
  int P, M;
  scanf("%d %d", &P, &M);
  if (P <= M) {
    cout << solvePmax(0, P);
  } else {
    cout << solveMmax(0, M);
  }
  return 0;
}

```