//#pragma GCC optimize ("Ofast, no-stack-protector, unroll-loops, fast-math, O3")

#include <bits/stdc++.h>
using namespace std;

const int N = 300+5;

int main_();

void fastIO() {
    std::ios::sync_with_stdio(0);
    cin.tie(0) ,cout.tie(0);
}

int main() {
    fastIO();
    int t = 1;
    //cin >> t;
    while(t--) {
        main_();
    }
    return 0;
}

string str;
int mem[N][N][N];
int solve1(int start,int lena, int lenb){
    if(lena==0 || lenb==0){
        return max(lena,lenb);
    }
    int&ret = mem[start][lena][lenb];
    if(~ret){
        return ret;
    }
    int i = start - lenb;
    int j = start + lena - 1;
    ret = min(solve1(start,lena,lenb-1)+1, solve1(start,lena-1,lenb)+1);
    if(str[i]==str[j]){
        ret = min(ret, solve1(start,lena-1, lenb-1));
    }
    else{
        ret = min(ret, solve1(start,lena-1, lenb-1) + 1);
    }
    return ret;
}

int rev[N][N][N];

int mem2[N][N][N];
int solve3(int l,int r,int i){
    if(r==str.size()-1){
        return 0;
    }
    if(i==str.size()){
        return 1e9+5;
    }
    int&ret = mem2[l][r][i];
    if(~ret){
        return ret;
    }
    ret = solve3(l,r,i+1);
    ret = min(ret, rev[l][r][i]+1 + solve3(r+1,i,i+1));
    return ret;
}
int main_() {
    cin >> str;
    memset(mem,-1,sizeof mem);
    for(int i=0;i<str.size();++i){
        for(int j=i;j<str.size();++j){
            int start = j+1;
            for(int k=start;k<str.size();++k){
                int lenb = j-i+1;
                int lena = k-start+1;
                rev[i][j][k] = solve1(start, lena, lenb);
            }
        }
    }

    memset(mem,-1,sizeof mem);
    memset(mem2,-1,sizeof mem2);
    int ans = str.size() + 1;
    for(int j=0;j<str.size();++j){
        ans = min(ans, j+2 + solve3(0,j,j+1));
    }
    cout << ans << endl;
    return 0;
}