#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }


int solve0(const string &S) {
  const int cnt0 = count(S.begin(), S.end(), '0');
  return cnt0 ? -1 : 0;
}
int solve00(const string &S) {
  const int N = S.size();
  const int cnt0 = count(S.begin(), S.end(), '0');
  if (cnt0 > N - N / 2) {
    return -1;
  }
  int ans = 0;
  for (int i = 0; i < N - 1; ++i) if (S[i] == '0' && S[i + 1] == '0') {
    ++ans;
  }
  return ans;
}
int solve01(const string &S) {
  const int N = S.size();
  int ans = 0;
  for (int i = 0, j = 0; i < N; i = j) {
    for (; j < N && S[i] == S[j]; ++j) {}
    if (S[i] == '1' && 0 < i) {
      ++ans;
    }
  }
  return ans;
}
int solve000(const string &S) {
  const int N = S.size();
  const int cnt0 = count(S.begin(), S.end(), '0');
  const int cnt1 = count(S.begin(), S.end(), '1');
  if (cnt0 > N - N / 3) {
    return -1;
  }
  int ans = 0;
  int a = 0, b = 0;
  for (int i = 0, j = 0; i < N; i = j) {
    for (; j < N && S[i] == S[j]; ++j) {}
    if (S[i] == '0') {
      ans += (j - i - 1) / 2;
      if (j - i == 1) {
        ++a;
      } else if ((j - i) % 2 != 0) {
        ++b;
      }
    }
  }
  a -= b;
  assert((cnt0 - a) % 2 == 0);
  for (; a + (cnt0 - a) / 2 > cnt1 + 1; ) {
    assert(a >= 2);
    ans += 1;
    a -= 2;
  }
  return ans;
}
int solve001(const string &S) {
  const int N = S.size();
  int ans = 0;
  for (int i = 0; i + 3 <= N; ++i) if (S[i] == '0' && S[i + 1] == '0' && S[i + 2] == '1') {
    ++ans;
  }
  return ans;
}
int solve010(const string &S) {
  return -2;
}

int solve(string T, string S) {
  const int M = T.size();
  const int N = S.size();
  if (T == "011" || T == "100") {
    reverse(T.begin(), T.end());
    reverse(S.begin(), S.end());
  }
  if (T[0] == '1') {
    for (int i = 0; i < M; ++i) T[i] ^= '0' ^ '1';
    for (int i = 0; i < N; ++i) S[i] ^= '0' ^ '1';
  }
  if (false) {}
  else if (T == "0") return solve0(S);
  else if (T == "00") return solve00(S);
  else if (T == "01") return solve01(S);
  else if (T == "000") return solve000(S);
  else if (T == "001") return solve001(S);
  else if (T == "010") return solve010(S);
  else assert(false);
}

void stress() {
  for (int m = 1; m <= 3; ++m) for (int q = 0; q < 1 << m; ++q) {
    string t(m, '?');
    for (int i = 0; i < m; ++i) t[i] = "01"[q >> i & 1];
    for (int n = 1; n <= 12; ++n) {
      queue<int> que;
      vector<int> dist(1 << n, -1);
      for (int u = 0; u < 1 << n; ++u) {
        string s(n, '?');
        for (int i = 0; i < n; ++i) s[i] = "01"[u >> i & 1];
        if (!~s.find(t)) {
          dist[u] = 0;
          que.push(u);
        }
      }
      for (; !que.empty(); ) {
        const int u = que.front();
        que.pop();
        string s(n, '?');
        for (int i = 0; i < n; ++i) s[i] = "01"[u >> i & 1];
        for (int l = 0; l < n; ++l) for (int r = l + 1; r <= n; ++r) {
          reverse(s.begin() + l, s.begin() + r);
          int v = 0;
          for (int i = 0; i < n; ++i) v |= (s[i] - '0') << i;
          if (!~dist[v]) {
            dist[v] = dist[u] + 1;
            que.push(v);
          }
          reverse(s.begin() + l, s.begin() + r);
        }
      }
      if (t == "001") {
        map<int, int> freq;
        for (int u = 0; u < 1 << n; ++u) {
          string s(n, '?');
          for (int i = 0; i < n; ++i) s[i] = "01"[u >> i & 1];
          ++freq[dist[u]];
          cout << t << " " << s << " " << dist[u] << endl;
        }
        cerr << n << ": "; pv(freq.begin(), freq.end());
      }
      for (int u = 0; u < 1 << n; ++u) {
        string s(n, '?');
        for (int i = 0; i < n; ++i) s[i] = "01"[u >> i & 1];
        const int slv = solve(t, s);
        if (slv != -2 && dist[u] != slv) {
          cerr << t << " " << s << ": " << dist[u] << " " << slv << endl;
          assert(false);
        }
      }
    }
  }
}


char S[200'010];
char T[3];

int main() {
#ifdef LOCAL
  stress();
#endif
  
  for (; ~scanf("%s%s", S, T); ) {
    const int ans = solve(string(T), string(S));
    printf("%d\n", ans);
  }
  return 0;
}