#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e4 + 20;
char s[maxn];
int dp[maxn][101][2];
int cnt[maxn];
int Index;
int k = 10;
int e = 0;
int a[maxn >> 1];
int b[maxn >> 1];
char MIN;
int minn;
void DP() {
  int x = b[--e];
  int y = b[--e];
  int pos = a[--Index];
  b[e++] = pos;
  if (x < 10 && y < 10) {
    dp[pos][0][0] = dp[pos][0][1] = (MIN == '+' ? y - x : y + x);
    if (minn > 0) dp[pos][1][0] = dp[pos][1][1] = (MIN == '+' ? y + x : y - x);
    cnt[pos] = min(1, minn);
  } else if (x > 9 && y < 10) {
    cnt[pos] = min(cnt[x] + 1, minn);
    if (MIN == '+') {
      dp[pos][0][0] = y - dp[x][0][1];
      dp[pos][0][1] = y - dp[x][0][0];
      for (int i = 1; i <= cnt[pos]; i++) {
        if (i > cnt[x]) {
          dp[pos][i][0] = y + dp[x][cnt[x]][0];
          dp[pos][i][1] = y + dp[x][cnt[x]][1];
          continue;
        }
        dp[pos][i][0] = min(y + dp[x][i - 1][0], y - dp[x][i][1]);
        dp[pos][i][1] = max(y + dp[x][i - 1][1], y - dp[x][i][0]);
      }
    } else {
      dp[pos][0][0] = y + dp[x][0][0];
      dp[pos][0][1] = y + dp[x][0][1];
      for (int i = 1; i <= cnt[pos]; i++) {
        if (i > cnt[x]) {
          dp[pos][i][0] = y - dp[x][cnt[x]][1];
          dp[pos][i][1] = y - dp[x][cnt[x]][0];
          continue;
        }
        dp[pos][i][0] = min(y + dp[x][i][0], y - dp[x][i - 1][1]);
        dp[pos][i][1] = max(y + dp[x][i][1], y - dp[x][i - 1][0]);
      }
    }
  } else if (x < 10 && y > 9) {
    cnt[pos] = min(cnt[y] + 1, minn);
    if (MIN == '+') {
      dp[pos][0][0] = dp[y][0][0] - x;
      dp[pos][0][1] = dp[y][0][1] - x;
      for (int i = 1; i <= cnt[pos]; i++) {
        if (i > cnt[y]) {
          dp[pos][i][0] = dp[y][cnt[y]][0] + x;
          dp[pos][i][1] = dp[y][cnt[y]][1] + x;
          continue;
        }
        dp[pos][i][0] = min(dp[y][i - 1][0] + x, dp[y][i][0] - x);
        dp[pos][i][1] = max(dp[y][i - 1][1] + x, dp[y][i][1] - x);
      }
    } else {
      dp[pos][0][0] = dp[y][0][0] + x;
      dp[pos][0][1] = dp[y][0][1] + x;
      for (int i = 1; i <= cnt[pos]; i++) {
        if (i > cnt[y]) {
          dp[pos][i][0] = dp[y][cnt[y]][0] - x;
          dp[pos][i][1] = dp[y][cnt[y]][1] - x;
          continue;
        }
        dp[pos][i][0] = min(dp[y][i][0] + x, dp[y][i - 1][0] - x);
        dp[pos][i][1] = max(dp[y][i][1] + x, dp[y][i - 1][1] - x);
      }
    }
  } else {
    cnt[pos] = min(minn, cnt[x] + cnt[y] + 1);
    if (MIN == '+') {
      dp[pos][0][0] = dp[y][0][0] - dp[x][0][1];
      dp[pos][0][1] = dp[y][0][1] - dp[x][0][0];
      for (int i = 1; i <= cnt[pos]; i++) {
        int Mi = 1000000000;
        int Ma = -1000000000;
        for (int j = 0; j <= i; j++) {
          if (j <= cnt[y] && i - j <= cnt[x]) {
            Mi = min(Mi, dp[y][j][0] - dp[x][i - j][1]);
            Ma = max(Ma, dp[y][j][1] - dp[x][i - j][0]);
          }
          if (i - j <= cnt[y] && j <= cnt[x]) {
            Mi = min(Mi, dp[y][i - j][0] - dp[x][j][1]);
            Ma = max(Ma, dp[y][i - j][1] - dp[x][j][1]);
          }
          if (j > 0 && j - 1 <= cnt[y] && i - j <= cnt[x]) {
            Mi = min(Mi, dp[y][j - 1][0] + dp[x][i - j][0]);
            Ma = max(Ma, dp[y][j - 1][1] + dp[x][i - j][1]);
          }
          if (j > 0 && j - 1 <= cnt[x] && i - j <= cnt[y]) {
            Mi = min(Mi, dp[y][i - j][0] + dp[x][j - 1][0]);
            Ma = max(Ma, dp[y][i - j][1] + dp[x][j - 1][1]);
          }
          if (i - j > 0 && i - j - 1 <= cnt[x] && j <= cnt[y]) {
            Mi = min(Mi, dp[y][j][0] + dp[x][i - j - 1][0]);
            Ma = max(Ma, dp[y][j][1] + dp[x][i - j - 1][1]);
          }
          if (i - j > 0 && i - j - 1 <= cnt[y] && j <= cnt[x]) {
            Mi = min(Mi, dp[y][i - j - 1][0] + dp[x][j][0]);
            Ma = max(Ma, dp[y][i - j - 1][1] + dp[x][j][1]);
          }
        }
        dp[pos][i][0] = Mi;
        dp[pos][i][1] = Ma;
      }
    } else {
      dp[pos][0][0] = dp[y][0][0] + dp[x][0][0];
      dp[pos][0][1] = dp[y][0][1] + dp[x][0][1];
      for (int i = 1; i <= cnt[pos]; i++) {
        int Mi = 1000000000;
        int Ma = -1000000000;
        for (int j = 0; j <= i; j++) {
          if (j <= cnt[y] && i - j <= cnt[x]) {
            Mi = min(Mi, dp[y][j][0] + dp[x][i - j][0]);
            Ma = max(Ma, dp[y][j][1] + dp[x][i - j][1]);
          }
          if (i - j <= cnt[y] && j <= cnt[x]) {
            Mi = min(Mi, dp[y][i - j][0] + dp[x][j][0]);
            Ma = max(Ma, dp[y][i - j][1] + dp[x][j][1]);
          }
          if (j > 0 && j - 1 <= cnt[y] && i - j <= cnt[x]) {
            Mi = min(Mi, dp[y][j - 1][0] - dp[x][i - j][1]);
            Ma = max(Ma, dp[y][j - 1][1] - dp[x][i - j][0]);
          }
          if (j > 0 && j - 1 <= cnt[x] && i - j <= cnt[y]) {
            Mi = min(Mi, dp[y][i - j][0] - dp[x][j - 1][1]);
            Ma = max(Ma, dp[y][i - j][1] - dp[x][j - 1][0]);
          }
          if (i - j > 0 && i - j - 1 <= cnt[x] && j <= cnt[y]) {
            Mi = min(Mi, dp[y][j][0] - dp[x][i - j - 1][1]);
            Ma = max(Ma, dp[y][j][1] - dp[x][i - j - 1][0]);
          }
          if (i - j > 0 && i - j - 1 <= cnt[y] && j <= cnt[x]) {
            Mi = min(Mi, dp[y][i - j - 1][0] - dp[x][j][1]);
            Ma = max(Ma, dp[y][i - j - 1][1] - dp[x][j][0]);
          }
        }
        dp[pos][i][0] = Mi;
        dp[pos][i][1] = Ma;
      }
    }
  }
}
int main() {
  scanf("%s", s);
  int len = strlen(s);
  if (len == 1) {
    printf("%d\n", s[0] - 48);
    return 0;
  }
  int p, m;
  scanf("%d%d", &p, &m);
  if (p < m) {
    MIN = '+';
    minn = p;
  } else {
    minn = m;
    MIN = '-';
  }
  for (int i = 0; i < len; i++) {
    if (s[i] == '(') {
      a[Index++] = k++;
    } else if (s[i] == ')') {
      DP();
    } else if (s[i] != '?') {
      b[e++] = s[i] - 48;
    }
  }
  printf("%d\n", dp[10][minn][1]);
  return 0;
}
