#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 <random>
#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; }
#define COLOR(s) ("\x1b[" s "m")


int TLen;
char T[150'010];

/*
  ans <= 3 |T|
  S[i]: needed
  ==> the solution crosses the boundary of S[i-1] S[i-2]
  ==> (|S[i-3]| >= 3 |T| ==> S[i-3] is enough)
*/
int I;
vector<int> SLen;

/*
  f[i][x]: max y' s.t. T[0, y') is subseq. of S[i][x, $)
  g[i][y]: max y' s.t. T[y, y') is subseq. of S[i]
*/
vector<vector<int>> f, g;

// min x' s.t. T[y, $) is subseq. of S[i][x, x')
int solve(int i, int x, int y) {
  if (y == 0) {
    assert(0 <= x); assert(x < SLen[i]);
    assert(f[i][x] == TLen);
    if (i < 2) {
      return 1;
    } else {
      return (x < SLen[i-1])
        ? ((f[i-1][x] == TLen) ? solve(i-1, x, 0) : (SLen[i-1] + solve(i-2, 0, f[i-1][x])))
        : (SLen[i-1] + solve(i-2, x - SLen[i-1], 0));
    }
  } else if (x == 0) {
    assert(0 <= y); assert(y < TLen);
    assert(g[i][y] == TLen);
    if (i < 2) {
      return 1;
    } else {
      return (g[i-1][y] == TLen) ? solve(i-1, 0, y) : (SLen[i-1] + solve(i-2, 0, g[i-1][y]));
    }
  } else {
    assert(false);
  }
}

int main() {
  for (; ~scanf("%s", T); ) {
    TLen = strlen(T);
    
    SLen = {1, 1};
    for (int i = 2; ; ++i) {
      SLen.push_back(0);
      SLen[i] = SLen[i-1] + SLen[i-2];
      if (i >= 3 && SLen[i-3] >= 3 * TLen) {
        I = i;
        break;
      }
    }
    
    f.resize(I + 1);
    g.assign(I + 1, vector<int>(TLen + 1));
    for (int i = 0; i <= I; ++i) {
      f[i].resize(SLen[i] + 1);
      if (i < 2) {
        f[i][0] = (T[0] == "ba"[i]) ? 1 : 0;
        f[i][1] = 0;
        for (int y = 0; y <= TLen; ++y) g[i][y] = (T[y] == "ba"[i]) ? (y + 1) : y;
      } else {
        for (int x = 0; x < SLen[i-1]; ++x) f[i][x] = g[i-2][f[i-1][x]];
        for (int x = SLen[i-1]; x <= SLen[i]; ++x) f[i][x] = f[i-2][x - SLen[i-1]];
        for (int y = 0; y <= TLen; ++y) g[i][y] = g[i-2][g[i-1][y]];
      }
    }
// for(int i=0;i<=I;++i)cerr<<i<<": "<<SLen[i]<<" "<<f[i]<<" "<<g[i]<<endl;
    
    int ans = SLen[I];
    for (int x = 0; x <= SLen[I]; ++x) if (f[I][x] == TLen) {
      const int xx = solve(I, x, 0);
      chmin(ans, xx - x);
    }
    printf("%d\n", ans);
  }
  return 0;
}