#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 <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; }


/*
  orz
  
  0[0101]0 -> 0[1010]0   0.... -> ....0
  0[0101]1 -> 0[1010]1   0...1 -> .....
  1[0101]0 -> 1[1010]0   ..... -> 1...0
  1[0101]1 -> 1[1010]1   ....1 -> 1....
*/

void experiment() {
  for (int n = 1; n <= 24; ++n) {
    vector<int> dp(1 << n, 0);
    vector<int> im(1 << n, -1);
    for (int p = 0; p < 1 << n; ++p) {
      for (int i = 0; i + 4 <= n; ++i) if ((p >> i & 15) == 10) {
        if (chmax(dp[p], 1 + dp[p ^ 15 << i])) {
          im[p] = i;
        }
      }
    }
    for (int p = 0; p < 1 << n; ++p) {
      string s(n + 1, '.');
      if ((p >> 0 & 1) == 1) s[0] = '1';
      for (int i = 1; i < n; ++i) {
        if ((p >> (i-1) & 3) == 0) s[i] = '0';
        if ((p >> (i-1) & 3) == 3) s[i] = '1';
      }
      if ((p >> (n-1) & 1) == 0) s[n] = '0';
      
      auto dump = [&]() -> void {
        cerr << "p = ";
        for (int i = 0; i < n; ++i) cerr << (p >> i & 1);
        cerr << endl;
        cerr << "s = " << s << endl;
        cerr << "dp[p] = " << dp[p] << ", im[p] = " << im[p] << endl;
      };
      
      vector<pair<char, int>> ics;
      for (int i = 0; i <= n; ++i) if (s[i] != '.') {
        ics.emplace_back(i, s[i]);
      }
      const int icsLen = ics.size();
      
      bool done = false;
      
      // 0...1 -> .....
      // 0.......1 -> ....0...1
      for (int j = 0; j < icsLen - 1; ++j) {
        if (ics[j].second == '0' &&
            ics[j + 1].second == '1' &&
            (ics[j + 1].first - ics[j].first) % 4 == 0) {
          done = true;
          const int i = ics[j].first;
          if (dp[p] != 1 + dp[p ^ 15 << i]) {
            cerr << "FAIL " << __LINE__ << " " << i << endl;
            dump();
            assert(false);
          }
        }
      }
      if (done) continue;
      
      // 0.... -> ....0 (no 1 to the right)
      for (int j = 0; j < icsLen; ++j) {
        if (ics[j].second == '0' &&
            (j + 1 == icsLen || ics[j + 1].second == '0')) {
          const int i = ics[j].first;
          if (i + 4 <= n && s.substr(i, 5) == "0....") {
            done = true;
            if (dp[p] != 1 + dp[p ^ 15 << i]) {
              cerr << "FAIL " << __LINE__ << " " << i << endl;
              dump();
              assert(false);
            }
          }
        }
      }
      // ....1 -> 1.... (no 0 to the left)
      for (int j = 0; j < icsLen; ++j) {
        if (ics[j].second == '1' &&
            (j == 0 || ics[j - 1].second == '1')) {
          const int i = ics[j].first - 4;
          if (i >= 0 && s.substr(i, 5) == "....1") {
            done = true;
            if (dp[p] != 1 + dp[p ^ 15 << i]) {
              cerr << "FAIL " << __LINE__ << " " << i << endl;
              dump();
              assert(false);
            }
          }
        }
      }
      if (done) continue;
      
      for (int j = 0; j < icsLen - 1; ++j) {
        if (ics[j].second == '0' &&
            ics[j + 1].second == '1' &&
            (ics[j + 1].first - ics[j].first >= 5)) {
          done = true;
          const int i0 = ics[j].first;
          const int i1 = ics[j + 1].first - 4;
          if (dp[p] != 1 + max(dp[p ^ 15 << i0], dp[p ^ 15 << i1])) {
            cerr << "FAIL " << __LINE__ << " " << i0 << " " << i1 << endl;
            dump();
            assert(false);
          }
        }
      }
      if (done) continue;
      
      for (int i = 0; i + 4 <= n; ++i) if (s.substr(i, 5) == ".....") {
        assert((p >> i & 15) == 10);
        done = true;
        if (dp[p] != 1 + dp[p ^ 15 << i]) {
          cerr << "FAIL " << __LINE__ << " " << i << endl;
          dump();
          assert(false);
        }
        break;
      }
      if (done) continue;
      
      if (dp[p] != 0) {
        cerr << "FAIL " << __LINE__ << endl;
        dump();
        assert(false);
      }
    }
    cerr << "DONE n = " << n << endl;
  }
}


int N;
char S[5'000'010];

int main() {
  // experiment();
  
  for (; ~scanf("%s", S); ) {
    N = strlen(S);
    
    Int ans = 0;
    
    int psLen = 0;
    vector<pair<int, char>> ps(N + 3);
    auto add = [&](int i, char c) -> void {
      ps[psLen++] = make_pair(i, c);
      if (psLen >= 2) {
        const int ii = ps[psLen - 2].first;
        const char cc = ps[psLen - 2].second;
        if (cc == '0' && c == '1' && (i - ii) % 4 == 0) {
          ans += (i - ii) / 4;
          psLen -= 2;
        }
      }
    };
    
    // 0...1 -> .....
    add(-1, '1');
    if (S[0] == '1') add(0, '1');
    for (int i = 1; i < N; ++i) {
      if (S[i - 1] == S[i]) add(i, S[i]);
    }
    if (S[N - 1] == '0') add(N, '0');
    add(N + 1, '0');
    
    ps.resize(psLen);
// cerr<<"ans = "<<ans<<", ps = "<<ps<<endl;
    
    // 0.... -> ....0
    for (int j = psLen - 1; --j >= 0; ) if (ps[j].second == '0' && ps[j + 1].second == '0') {
      const int t = (ps[j + 1].first - ps[j].first) / 4;
      ans += t;
      ps[j].first += 4 * t;
    }
    // ....1 -> 1....
    for (int j = 1; j < psLen; ++j) if (ps[j].second == '1' && ps[j - 1].second == '1') {
      const int t = (ps[j].first - ps[j - 1].first) / 4;
      ans += t;
      ps[j].first -= 4 * t;
    }
// cerr<<"ans = "<<ans<<", ps = "<<ps<<endl;
    
    // ..... -> 1...0
    vector<Int> emerge(N + 3, 0);
    for (int n = 6; n < N + 3; ++n) {
      const int t = (n - 2) / 4;
      emerge[n] = t + emerge[4 * t];
    }
// cerr<<"emerge = "<<emerge<<endl;
    
    int is[2] = {-1, -1};
    Int fs[2] = {0, 0};
    for (int j0 = 0, j1, j2; j0 < psLen; j0 = j2) {
      for (j1 = j0; j1 < psLen && ps[j1].second == '0'; ++j1) {}
      for (j2 = j1; j2 < psLen && ps[j2].second == '1'; ++j2) {}
      if (j0 == 0) {
        assert(j0 == j1);
        assert(j1 < j2);
        for (int x = 0; x < 2; ++x) {
          is[x] = ps[j2 - 1].first;
        }
      } else if (j2 == psLen) {
        assert(j0 < j1);
        assert(j1 == j2);
        for (int x = 0; x < 2; ++x) {
          fs[x] += emerge[ps[j0].first - is[x]];
        }
      } else {
        assert(j0 < j1);
        assert(j1 < j2);
        const int t = (ps[j1].first - ps[j1 - 1].first) / 4;
        int iis[2] = {-1, -1};
        Int ffs[2] = {-1, -1};
        // 0.... -> ....0
        {
          iis[0] = ps[j2 - 1].first;
          for (int x = 0; x < 2; ++x) {
            chmax(ffs[0], fs[x] + emerge[(ps[j0].first + 4 * t) - is[x]]);
          }
          ffs[0] += (Int)(j1 - j0) * t;
        }
        // ....1 -> 1....
        {
          iis[1] = ps[j2 - 1].first - 4 * t;
          for (int x = 0; x < 2; ++x) {
            chmax(ffs[1], fs[x] + emerge[ps[j0].first - is[x]]);
          }
          ffs[1] += (Int)(j2 - j1) * t;
        }
        copy(iis, iis + 2, is);
        copy(ffs, ffs + 2, fs);
      }
    }
    ans += max(fs[0], fs[1]);
    
    printf("%lld\n", ans);
  }
  return 0;
}