#include<iostream>
#include<cstring>
#include<vector>
using namespace std;
using LL = long long;
const int M = 40;
int dp[M + 1][150005];

int main(){

#ifdef LOCAL
    freopen("data.in", "r", stdin);
    freopen("data.out", "w", stdout);
#endif

    cin.tie(0);
    cout.tie(0);
    ios::sync_with_stdio(0);

    int fib[M + 1];
    fib[0] = fib[1] = 1;
    for(int i = 2; i <= M; i++){
        fib[i] = fib[i - 1] + fib[i - 2];
    }

    string t;
    cin >> t;
    const int n = t.size();
    for(int i = 0; i < n; i++){
        dp[0][i] = (t[i] == 'b');
        dp[1][i] = (t[i] == 'a');
    }
    for(int i = 2; i <= M; i++){
        for(int j = 0; j < n; j++){
            dp[i][j] = dp[i - 1][j] + dp[i - 2][j + dp[i - 1][j]];
        }
    }

  auto dfs = [&](auto& dfs, int i, int j, int k) -> pair<int, int> {
    // S[i][j:] から t[k:] をとるときの (とれる文字数, cost)

    if (k == n) return {0, 0};
    if (i == 0) {
      if (t[k] == 'b') { return {1, 1}; }
      if (t[k] == 'a') { return {0, 1}; }
    }
    if (i == 1) {
      if (t[k] == 'a') { return {1, 1}; }
      if (t[k] == 'b') { return {0, 1}; }
    }

    if (j == 0) {
      if (k + dp[i][k] < n) return {dp[i][k], fib[i]};
      int get = dp[i - 1][k];
      if (get < n - k) {
        auto [a, b] = dfs(dfs, i - 2, 0, k + get);
        return {get + a, fib[i - 1] + b};
      }
      auto [a, b] = dfs(dfs, i - 1, 0, k);
      return {a, b};
    }
    if (j < fib[i - 1]) {
      auto [a, b] = dfs(dfs, i - 1, j, k);
      if (k + a == n) return {a, b};
      auto [c, d] = dfs(dfs, i - 2, 0, k + a);
      return {a + c, b + d};
    } else {
      return dfs(dfs, i - 2, j - fib[i - 1], k);
    }
  };

    // // 在s[i][j:]位置匹配t[k:]能匹配的长度和需要的代价
    // auto dfs = [&](auto &&dfs, int i, int j, int k) -> pair<int, int> {
    //     if (k == n) return {0, 0};
    //     if (i == 0){
    //         if (t[k] == 'b') return {1, 1};
    //         return {0, 1};
    //     }
    //     if (i == 1){
    //         if (t[k] == 'a') return {1, 1};
    //         return {0, 1};
    //     }

    //     if (j == 0){
    //         if (k + dp[i][k] < n) return {dp[i][k], fib[i]};
    //         if (k + dp[i - 1][k] < n){
    //             auto [a, b] = dfs(dfs, i - 2, 0, k + dp[i - 1][k]);
    //             return {a + dp[i - 1][k], b + fib[i - 1]};
    //         }
    //         return dfs(dfs, i - 1, 0, k);
    //     }
    //     if (j < fib[i - 1]){
    //         auto [a, b] = dfs(dfs, i - 1, j, k);
    //         if (k + a == n) return {a, b};
    //         auto [c, d] = dfs(dfs, i - 2, 0, k + a);
    //         return {a + c, b + d};
    //     }
    //     return dfs(dfs, i - 2, j - fib[i - 1], k);
    // };

    const int N = 500000;

    int ans = 1e9;
    for(int i = 0; i < N; i++){
        ans = min(ans, dfs(dfs, 30, i, 0).second);
    }
    cout << ans << '\n';

}