// Arup Guha
// 3/22/2023
// Solution to 2022 SER D1/D2 Problem: Alchemy

using namespace std;

#include <iostream>

string s;
int n;
int memo[110][4];

int go(int k, int match);
int min(int a, int b);
int regMask(int k);
int solve() ;

int main() {

    cin >> s;
    n = s.size();

    for (int i=0; i<110; i++)
        for (int j=0; j<4; j++)
            memo[i][j] = -1;

    cout << solve() << endl;

    return 0;
}

// Wrapper function.
int solve() {

    // Brute force these cases.
    if (n == 2 || n == 3) {
        if (s[0] == s[n-1]) return 0;
        return 1;
    }

    // Get it going!
    int b1 = (s[0] != s[n-1]);
    int b2 = (s[1] != s[n-2]);
    return go(0, (b1<<1)+b2 );
}

int go(int k, int mask) {

    // Matching index to k on right.
    int mI = n-k-1;

    // This is always 0.
    if (mI == k) return 0;

    // This depends on the mask (what matches and what doesn't.)
    if (mI == k+1 || mI == k+2) {
        return mask&2 ? 1 : 0;
    }

    // Same here.
    if (mI == k+3) {
        if (mask == 0) return 0;
        if (mask&1) return 1;
        return 2;
    }

    // Did this before...
    if (memo[k][mask] != -1) return memo[k][mask];

    // Both letter match, let's be greedy.
    if (mask == 0) return memo[k][mask] = go(k+2, regMask(k+2));

    // The outer letter matches but not the inner letter.
    if (mask == 1) {

        // We don't change position k and move to k+1.
        int tmp1 = go(k+1, regMask(k+1));

        // We need to swaps to fix the next two positions.
        int tmp2 = 2 + go(k+2, regMask(k+2));

        // Return the best of these options.
        return memo[k][mask] = min(tmp1, tmp2);
    }

    // Inner letters match but outer ones don't.
    if (mask == 2) {

        // Change the outer letters to match, but this forces a mismatch
        // for the inner letters, which are the new outer letters.
        int tmp1 = 1 + go(k+1, 2+(s[k+2]!=s[mI-2]));

        // We can always fix two letters in 2 changes.
        int tmp2 = 2 + go(k+2, regMask(k+2));

        // Return the best...
        return memo[k][mask] = min(tmp1, tmp2);
    }

    // If we get here, no letters match.

    // We can fix two errors with one operation.
    int tmp1 = 1 + go(k+2, regMask(k+2));

    // Just go ahead and fix the first letter and the second, but recursively
    // run from spot k+1, just in case!
    int tmp2 = 1 + go(k+1, s[k+2]!=s[mI-2]);

    // Fix the outer letter, but not the inner letter...
    int tmp3 = 1 + go(k+1, 2 + (s[k+2]!=s[mI-2])  );

    // Take the smallest of these three options.
    int res = min(tmp1, tmp2);
    res = min(res, tmp3);
    return memo[k][mask] = res;
}

// Returns the regular mask at position k (1 = mismatch inner letters, 2 = mismatch outer letters)
// Based on original string letters.
int regMask(int k) {
    int mI = n-k-1;
    int b1 = (s[k] != s[mI]);
    int b2 = (s[k+1] != s[mI-1]);
    return (b1<<1)+b2;
}

int min(int a, int b) {
    return a < b ? a : b;
}