#include<iostream>
#include<map>
#include<string>
#include<fstream>
#include<vector>

int main()
{
    std::string ulaz;
    std::string preradjen_ulaz; //Svi simetricni delovi izbaceni
    std::vector<int> indices;   //Indeksi svih karaktera iz preradjenog ulaza
    std::cin >> ulaz;
    int len = ulaz.length();
    int middle = len/2;
    int l_granica = 0;
    int d_granica = len-1;
    bool odd_string = false;
    std::cin;

    odd_string = len & 1;
    std::map<char, int> ulazni_char_count;
    for(int i = 0; i < len; i++)
        ulazni_char_count[ulaz[i]]++;
    
    char odd = 0;   //Karakter koji se pojavljuje neparan broj puta
    for(auto& memb : ulazni_char_count)
    {
        if(memb.second & 1)
            odd = memb.first;
    }
    bool odd_is_middle = false;
    if((odd_string) && (ulaz[middle] == odd))
        odd_is_middle = true;

    int offset = 0;
    for(int i = 0; i < len; i++)
    {
        if(ulaz[i] != ulaz[len - 1 - i])
        {
            offset = i;
            break;
        }
        else
            offset++;
    }

    if(offset == len)
    {
        std::cout << "1\n";
        return 0;
    }

    for(int i = offset; i < len - offset; i++)
    {
        if((odd_string) && (odd_is_middle) && (i == middle))
            continue;
        else
        {
            preradjen_ulaz.push_back(ulaz[i]);
            indices.push_back(i);
        }
    }
    //std::cout << preradjen_ulaz << "\n";

    std::map<char, int> chars_needed;   //Koliko je puta karakter potreban kako bi se od podstringa mogao napraviti palindrom
    std::map<char, int> preradjeni_count;
    for(char c : preradjen_ulaz)
        preradjeni_count[c]++;

    for(auto& memb : preradjeni_count)
        chars_needed[memb.first] = memb.second / 2;

    if((odd != 0) && (!odd_is_middle))
        chars_needed[odd]++;

    std::map<char, int> nadjeni_karakteri;

    int preradjen_len = preradjen_ulaz.length();
    //Trazenje najkraceg podstringa pocev od leve strane
    int l_velicina = 0;

    for(int i = 0; i < preradjen_len; i++)
    {
        nadjeni_karakteri[preradjen_ulaz[i]]++;

        bool gotovo = true;
        for(auto& memb : chars_needed)
        {
            if(nadjeni_karakteri[memb.first] < memb.second)
                gotovo = false;
        }
        if(gotovo)
        {
            l_velicina = indices[i] - indices[0] + 1;
            break;
        }
    }

    nadjeni_karakteri.clear();
    int d_velicina = 0;

    for(int i = preradjen_len - 1; i >= 0; i--)
    {
        nadjeni_karakteri[preradjen_ulaz[i]]++;

        bool gotovo = true;
        for(auto& memb : chars_needed)
        {
            if(nadjeni_karakteri[memb.first] < memb.second)
                gotovo = false;
        }
        if(gotovo)
        {
            d_velicina = indices[preradjen_len-1] - indices[i] + 1;
            break;
        }
    }

    int najbrzi = (d_velicina < l_velicina)? d_velicina : l_velicina;
    int odgovor = (najbrzi > 1) ? najbrzi : 1;

    // for(auto& memb : chars_needed)
    //     std::cout << memb.first << ", " << memb.second << "\n";
        
    // std::cout << l_velicina << ", " << d_velicina << "\n";
    std::cout << odgovor << '\n';

    return 0;
}