#include <bits/stdc++.h>
using namespace std;
#define debug(fmt, ...) \
  fprintf(stderr, "[%d] " fmt "\n", __LINE__, ##__VA_ARGS__)
template <class _Tx, class _Ty>
inline void chkmin(_Tx& x, const _Ty& y) {
  x = min<common_type_t<_Tx, _Ty>>(x, y);
}
template <class _Tx, class _Ty>
inline void chkmax(_Tx& x, const _Ty& y) {
  x = max<common_type_t<_Tx, _Ty>>(x, y);
}
using ll = long long;
using ull = unsigned long long;
using i128 = __int128_t;
using u128 = __uint128_t;
bool Mbe;

constexpr int N = 1e4 + 10;

bool is_number(char ch) {
  return '0' <= ch && ch <= '9';
}

vector<string> insert_concat(const vector<string>& tokens) {
  vector<string> result;
  for (int i = 0; i < (int)tokens.size(); ++i) {
    result.push_back(tokens[i]);
    if (i + 1 < (int)tokens.size() &&
        tokens[i] != "|" &&
        tokens[i] != "(" &&
        tokens[i + 1] != "|" &&
        tokens[i + 1] != "+" &&
        tokens[i + 1] != ")")
      result.push_back("-");
  }
  return result;
}

vector<string> get_tokens(const string& expr) {
  vector<string> tokens;
  tokens.push_back("("s);
  for (int i = 0; i < (int)expr.size(); ++i) {
    if (expr[i] == '[') {
      int j = i;
      while (j < (int)expr.size() && expr[j] != ']') ++j;
      assert(j < (int)expr.size());
      tokens.push_back(expr.substr(i, j - i + 1));
      i = j;
    } else {
      tokens.push_back(string{expr[i]});
    }
  }
  tokens.push_back(")"s);
  // cerr << "== original tokens\n";
  // for (auto it : tokens) cerr << " - $" << it << "$\n";
  tokens = insert_concat(tokens);
  // cerr << "== tokens with concatenations\n";
  // for (auto it : tokens) cerr << " - $" << it << "$\n";
  return tokens;
}

namespace nfa {
int pn;
vector<pair<int, char>> nxt[N];
int new_node() {
  return ++pn;
}
void add_edge(int u, int v, char ch) {
  // cerr << " - (" << u << ", " << v << ", " << ch << ")\n";
  nxt[u].push_back({v, ch});
}
} // namespace nfa

template <class _Tp>
_Tp pop_back(vector<_Tp>& stk) {
  _Tp ret = stk.back();
  return stk.pop_back(), ret;
}

struct node {
  int s, t;
};

node unary_op(const string& op, const node& u) {
  if (op == "+") {
    int s = nfa::new_node();
    int t = nfa::new_node();
    nfa::add_edge(s, u.s, '\0');
    nfa::add_edge(u.t, t, '\0');
    nfa::add_edge(u.t, u.s, '\0');
    return {s, t};
  } else if (op == "*") {
    int s = nfa::new_node();
    int t = nfa::new_node();
    nfa::add_edge(s, u.s, '\0');
    nfa::add_edge(u.t, t, '\0');
    nfa::add_edge(u.s, u.t, '\0');
    nfa::add_edge(u.t, u.s, '\0');
    return {s, t};
  } else {
    assert(0);
  }
}

node binary_op(const string& op, const node& u, const node& v) {
  if (op == "|") {
    int s = nfa::new_node();
    int t = nfa::new_node();
    nfa::add_edge(s, u.s, '\0');
    nfa::add_edge(s, v.s, '\0');
    nfa::add_edge(u.t, t, '\0');
    nfa::add_edge(v.t, t, '\0');
    return {s, t};
  } else if (op == "-") {
    nfa::add_edge(u.t, v.s, '\0');
    return {u.s, v.t};
  } else {
    assert(0);
  }
}

node get_nfa(const vector<string>& tokens) {
  vector<node> stkn;
  vector<string> stkop;
  // cerr << "== build nfa\n";
  for (auto it : tokens) {
    // cerr << "=== step $" << it << "$\n";
    if (it[0] == '[') {
      node p;
      p.s = nfa::new_node();
      p.t = nfa::new_node();
      for (int i = 1; i + 1 < (int)it.size(); ++i)
        nfa::add_edge(p.s, p.t, it[i]);
      stkn.push_back(p);
    } else if (is_number(it[0])) {
      node p;
      p.s = nfa::new_node();
      p.t = nfa::new_node();
      nfa::add_edge(p.s, p.t, it[0]);
      stkn.push_back(p);
    } else if (it == "(") {
      stkop.push_back(it);
    } else if (it == ")") {
      while (!stkop.empty() && stkop.back() != "(") {
        string op = pop_back(stkop);
        node v = pop_back(stkn), u = pop_back(stkn);
        stkn.push_back(binary_op(op, u, v));
      }
      assert(!stkop.empty() && stkop.back() == "(");
      stkop.pop_back();
    } else if (it == "+" || it == "*") {
      assert(!stkn.empty());
      node u = pop_back(stkn);
      stkn.push_back(unary_op(it, u));
    } else if (it == "|") {
      while (!stkop.empty() && stkop.back() == "-") {
        string op = pop_back(stkop);
        node v = pop_back(stkn), u = pop_back(stkn);
        stkn.push_back(binary_op(op, u, v));
      }
      stkop.push_back(it);
    } else if (it == "-") {
      stkop.push_back(it);
    }
    // for (auto it : stkop) cerr << it << " ";
    // cerr << "\n";
  }
  assert(stkop.empty());
  assert(stkn.size() == 1);
  return stkn[0];
}

int dp[N][N];

bool Med;
int main() {
  // debug("Mem: %.4lfMB.", fabs(&Med - &Mbe) / 1048576);
  cin.tie(0)->sync_with_stdio(0);
  string str, expr;
  cin >> expr >> str;
  node g = get_nfa(get_tokens(expr));
  int m = str.size();
  memset(dp, 0x3f, sizeof(dp));
  deque<tuple<int, int, int>> dq;
  dq.push_back({g.s, 0, 0}), dp[g.s][0] = 0;
  while (!dq.empty()) {
    int x, y, d;
    tie(x, y, d) = dq.front();
    dq.pop_front();
    if (d > dp[x][y]) continue;
    if (y < m) {
      if (dp[x][y + 1] > d + 1) {
        dp[x][y + 1] = d + 1;
        dq.push_back({x, y + 1, d + 1});
      }
    }
    for (auto it : nfa::nxt[x]) {
      int v = it.first;
      char ch = it.second;
      if (ch == '\0') {
        if (dp[v][y] > d) {
          dp[v][y] = d;
          dq.push_front({v, y, d});
        }
      } else {
        if (y < m && str[y] == ch) {
          if (dp[v][y + 1] > d) {
            dp[v][y + 1] = d;
            dq.push_front({v, y + 1, d});
          }
        }
        if (y < m) {
          if (dp[v][y + 1] > d + 1) {
            dp[v][y + 1] = d + 1;
            dq.push_back({v, y + 1, d + 1});
          }
        }
        if (dp[v][y] > d + 1) {
          dp[v][y] = d + 1;
          dq.push_back({v, y, d + 1});
        }
      }
    }
  }
  cout << dp[g.t][m] << '\n';
  return 0;
}
/*
g++ -std=c++14 -O2 -o qoj-6600 qoj-6600.cpp -Wall -Wextra
-Wshadow -fsanitize=address,undefined -g
*/