import java.util.*;
import java.io.*;

public class SwapForPalindromeMN {

  static class Kattio extends PrintWriter {
    public Kattio(InputStream i) {
      super(new BufferedOutputStream(System.out));
      this.r = new BufferedReader(new InputStreamReader(i));
    }

    public Kattio(InputStream i, OutputStream o) {
      super(new BufferedOutputStream(o));
      this.r = new BufferedReader(new InputStreamReader(i));
    }

    public boolean hasMoreTokens() {
      return this.peekToken() != null;
    }

    public int getInt() {
      return Integer.parseInt(this.nextToken());
    }

    public double getDouble() {
      return Double.parseDouble(this.nextToken());
    }

    public long getLong() {
      return Long.parseLong(this.nextToken());
    }

    public String getWord() {
      return this.nextToken();
    }

    private BufferedReader r;
    private String line;
    private StringTokenizer st;
    private String token;

    private String peekToken() {
      if (this.token == null) {
        try {
          while (this.st == null || !this.st.hasMoreTokens()) {
            this.line = this.r.readLine();
            if (this.line == null) {
              return null;
            }
            this.st = new StringTokenizer(this.line);
          }
          this.token = this.st.nextToken();
        } catch (IOException e) {
        }
      }

      return this.token;
    }

    private String nextToken() {
      String ans = this.peekToken();
      this.token = null;
      return ans;
    }
  }

  static class Pair {
    public int first, second;

    public Pair(int f, int s) {
      this.first = f;
      this.second = s;
    }
  }

  static boolean works(ArrayList<Pair> mismatch, int[] cnt, int center) {
    if (mismatch.isEmpty())
      return true;
    if (mismatch.size() == 1) {
      return mismatch.get(0).first == center
          || mismatch.get(0).second == center
          || cnt[mismatch.get(0).first] > 0
          || cnt[mismatch.get(0).second] > 0;
    }
    if (mismatch.size() == 2) {
      return mismatch.get(0).first == mismatch.get(1).first && mismatch.get(0).second == mismatch.get(1).second;
    }
    return false;
  }

  static int solve(String s, int l, int r) {
    int[] cnt = new int[26];
    ArrayList<Pair> mismatch = new ArrayList<>();
    for (int i = 0; i < s.length(); i++) {
      cnt[(int) (s.charAt(i)) - 97]++;
    }
    int center = (l == r) ? ((int) (s.charAt(l)) - 97) : -1;
    int ret = 0;
    while (l >= 0 && r < s.length()) {
      int cl = s.charAt(l) - 97;
      int cr = s.charAt(r) - 97;
      cnt[cl]--;
      cnt[cr]--;
      if (cl == cr) {
        if (works(mismatch, cnt, center)) {
          ret = Math.max(ret, r - l + 1);
        }
        l--;
        r++;
      } else {
        mismatch.add(new Pair(Math.min(cl, cr), Math.max(cl, cr)));
        if (mismatch.size() >= 3) {
          break;
        }
        if (works(mismatch, cnt, center)) {
          ret = Math.max(ret, r - l + 1);
        }
        l--;
        r++;
      }
    }
    return ret;
  }

  public static void main(String[] args) throws IOException {
    Kattio io = new Kattio(System.in, System.out);

    String s = io.nextToken();
    int n = s.length();

    int ret = 1;

    for (int i = 0; i < n; i++) {
      ret = Math.max(ret, solve(s, i, i));
      if (i + 1 < n) {
        ret = Math.max(ret, solve(s, i, i + 1));
      }
    }

    io.println(ret);
    io.close();

  }
}