import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.TreeSet;
import java.util.ArrayList;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Pradyumn
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastReader in = new FastReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskD solver = new TaskD();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskD {
        public void solve(int testNumber, FastReader in, PrintWriter out) {
            char[] s = in.nextString().toCharArray();
            int n = s.length;
            int[] next = new int[n];
            int[] prev = new int[n];
            for (int i = 0; i < n; ++i) {
                prev[i] = i - 1;
                next[i] = i + 1;
            }
            TreeSet<Integer> set = new TreeSet<>();
            for (int i = 1; i < n; ++i) {
                if (s[i] != s[i - 1]) {
                    set.add(i - 1);
                    set.add(i);
                }
            }
            int ans = 0;
            while (!set.isEmpty()) {
                ++ans;
                TreeSet<Integer> temp = new TreeSet<>();
                ArrayList<Integer> arr = new ArrayList<>();
                for (Integer ss : set) arr.add(ss);
                for (Integer cur : arr) {
                    if (!set.contains(cur)) continue;
                    int l = prev[cur];
                    while (set.contains(cur)) {
                        set.remove(cur);
                        cur = next[cur];
                    }
                    if (l >= 0)
                        next[l] = cur;
                    if (cur < n)
                        prev[cur] = l;
                    if (l >= 0 && cur < n && s[l] != s[cur]) {
                        temp.add(l);
                        temp.add(cur);
                    }
                }
                set = temp;
            }
            out.println(ans);
        }

    }

    static class FastReader {
        private InputStream stream;
        private byte[] buf = new byte[8192];
        private int curChar;
        private int pnumChars;

        public FastReader(InputStream stream) {
            this.stream = stream;
        }

        private int pread() {
            if (pnumChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= pnumChars) {
                curChar = 0;
                try {
                    pnumChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (pnumChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public String nextString() {
            int c = pread();
            while (isSpaceChar(c))
                c = pread();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = pread();
            } while (!isSpaceChar(c));
            return res.toString();
        }

        private boolean isSpaceChar(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

    }
}

