After his wife's tragic death, Eurydice, Orpheus descended to the realm of death to see her. Reaching its gates was uneasy, but passing through them proved to be even more challenging. Mostly because of Cerberus, the three-headed hound of Hades. 

Orpheus, a famous poet, and musician plans to calm Cerberus with his poetry and safely walk past him. He created a very peculiar poem for Cerberus. It consists only of lowercase English letters. 

We call a poem's substring a palindrome if and only if it reads the same backwards and forwards. A string a is a substring of a string b if a can be obtained from b by deleting several (possibly zero or all) characters from the beginning and several (possibly zero or all) characters from the end.

Unfortunately, Cerberus dislikes palindromes of length greater than 1. For example in the poem abaa the hound of Hades wouldn't like substrings aba and aa.

Orpheus can only calm Cerberus if the hound likes his poetry. That's why he wants to change his poem so that it does not contain any palindrome substrings of length greater than 1.

Orpheus can modify the poem by replacing a letter at any position with any lowercase English letter. He can use this operation arbitrarily many times (possibly zero). Since there can be many palindromes in his poem, he may have to make some corrections. But how many, exactly? Given the poem, determine the minimal number of letters that have to be changed so that the poem does not contain any palindromes of length greater than 1.

Input

The first line of the input contains a single integer t (1 ≤ t ≤ 10^5) denoting the number of test cases, then t test cases follow.

The first and only line of each test case contains a non-empty string of lowercase English letters, Orpheus' poem.

The sum of the length of Orpheus' poems in all test cases will not exceed 10^5.

Output

You should output t lines, i-th line should contain a single integer, answer to the i-th test case.

Example

Input


7
babba
abaac
codeforces
zeroorez
abcdcba
bbbbbbb
a


Output


1
1
0
1
1
4
0

Note

In the first test case, we can replace the third character with c and obtain a palindrome-less poem bacba.

In the second test case, we can replace the third character with d and obtain a palindrome-less poem abdac.

In the third test case, the initial poem already doesn't contain any palindromes, so Orpheus doesn't need to change anything there.
// package cf.cf1466;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.Random;
import java.util.function.IntConsumer;

public class C {
    private static final String INPUT = "12\n" +
            "babba\n" +
            "abaac\n" +
            "codeforces\n" +
            "zeroorez\n" +
            "abcdcba\n" +
            "bbbbbbb\n" +
            "a\n" +
            "aa\n" +
            "aaa\n" +
            "aaaa\n" +
            "aaaaa\n" +
            "dadada\n";
    private static final int MOD = 1_000_000_007;

    FastScanner sc;
    PrintWriter out;

    public static void main(String[] args) {
        new C().run();
    }

    public C() {
        sc = new FastScanner(oj ? System.in : new ByteArrayInputStream(INPUT.getBytes()));
        out = new PrintWriter(System.out);
    }

    public void run() {
        long start = System.currentTimeMillis();
        times(sc.nextInt(), this::solve);
        out.flush();
        tr(System.currentTimeMillis() - start + "ms");
    }

    public void solve(int time) {
        int[] line = sc.nextLine().chars().map(ch -> ch - 'a').toArray();

        int bad = -1;
        switch (line.length) {
            case 1: answer(0);
            case 2: answer(line[0] == line[1] ? 1 : 0);
            default:
                int ans = 0;
                int prev2 = line[0];
                int prev1 = line[1];
                if (prev1 == prev2) ans++;
                for (int i = 2; i < line.length; i++) {
                    if (line[i] == prev2) {
                        ans++;
                        if (prev1 == prev2
                                || (i < line.length - 1 && line[i-1] != line[i+1])
                                || (i >= 3 && line[i-1] == line[i-3])) {
                            line[i] = bad--;
                            line[i - 1] = bad--;
                        }
                    } else if (line[i] == prev1) {
                        ans++;
                    }
                    prev1 = line[i];
                    prev2 = line[i-1];
                }
                answer(ans);
        }


        writeln(1);
    }

    boolean ok(long n) {
        long d = n;
        while(d > 0) {
            long d2 = d % 10;
            if (d2 != 0 && n%d2 != 0) return false;

            d /= 10;
        }
        return d == 0;
    }

    //---------------------------------------------------------------------------------------------------

    /**
     * If searched element doesn't exist, returns index of first element which is bigger than searched value.<br>
     * If searched element is bigger than any array element function returns first index after last element.<br>
     * If searched element is lower than any array element function returns index of first element.<br>
     * If there are many values equals searched value function returns first occurrence.<br>
     */
    private static int lowerBound(long[] arr, long key) {
        int lo = 0;
        int hi = arr.length - 1;
        while (lo < hi) {
            int mid = (lo + hi) / 2;
            if (key <= arr[mid]) {
                hi = mid - 1;
            } else {
                lo = mid + 1;
            }
        }
        return arr[lo] < key ? lo + 1 : lo;
    }

    /**
     * Returns index of first element which is grater than searched value.
     * If searched element is bigger than any array element, returns first index after last element.
     */
    private static int upperBound(long[] arr, long key) {
        int lo = 0;
        int hi = arr.length - 1;
        while (lo < hi) {
            int mid = (lo + hi) / 2;
            if (key >= arr[mid]) {
                lo = mid + 1;
            } else {
                hi = mid;
            }
        }
        return arr[lo] <= key ? lo + 1 : lo;
    }

    private static int upperBound(int[] arr, int key) {
        int lo = 0;
        int hi = arr.length - 1;
        while (lo < hi) {
            int mid = (lo + hi) / 2;
            if (key >= arr[mid]) {
                lo = mid + 1;
            } else {
                hi = mid;
            }
        }
        return arr[lo] <= key ? lo + 1 : lo;
    }

    private long[] prefixSum(long[] array) {
        long[] result = new long[array.length];
        result[0] = array[0];
        for (int i = 1; i < array.length; i++) result[i] = result[i - 1] + array[i];
        return result;
    }

    private int[] sort(int[] array) {
        shuffle(array);
        Arrays.sort(array);
        return array;
    }

    private static void shuffle(int[] array) {
        Random random = new Random();
        for (int i = array.length - 1; i > 0; i--) {
            int index = random.nextInt(i + 1);
            {
                int tmp = array[index];
                array[index] = array[i];
                array[i] = tmp;
            }
        }
    }

    private static int gcd(int a, int b) {
        BigInteger b1 = BigInteger.valueOf(a);
        BigInteger b2 = BigInteger.valueOf(b);
        BigInteger gcd = b1.gcd(b2);
        return gcd.intValue();
    }

    private long[] sort(long[] array) {
        shuffle(array);
        Arrays.sort(array);
        return array;
    }

    private static void shuffle(long[] array) {
        Random random = new Random();
        for (int i = array.length - 1; i > 0; i--) {
            int index = random.nextInt(i + 1);
            {
                long tmp = array[index];
                array[index] = array[i];
                array[i] = tmp;
            }
        }
    }

    static class ExitException extends RuntimeException {
    }

    private int iread() {
        int res = sc.nextInt();
        if (res <= 0) {
            throw new ExitException();
        }
        return res;
    }

    private void iwrite(char[] chars) {
        for (char chr : chars) {
            out.print(chr);
        }
        out.println();
        out.flush();
    }

    private void write(Object obj) {
        out.print(obj);
    }

    private void writeln(Object obj) {
        out.println(obj);
    }

    private void writeln() {
        out.println();
    }

    private void answer(Object ans) {
        out.println(ans);
        throw new ExitException();
    }

    private void times(int n, IntConsumer consumer) {
        for (int i = 0; i < n; i++) {
            try {
                consumer.accept(i);
            } catch (ExitException ignored) {
            }
        }
    }

    private int[] readIntArray(int n) {
        int[] res = new int[n];
        for (int i = 0; i < n; i++) {
            res[i] = sc.nextInt();
        }
        return res;
    }

    private long[] readLongArray(int n) {
        long[] res = new long[n];
        for (int i = 0; i < n; i++) {
            res[i] = sc.nextLong();
        }
        return res;
    }

    static class FastScanner {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;

        FastScanner(InputStream stream) {
            this.stream = stream;
        }

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

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

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

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }

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

        public String nextLine() {
            int c = read();
            while (isEndline(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isEndline(c));
            return res.toString();
        }

    }

    private boolean oj = System.getProperty("ONLINE_JUDGE") != null;

    private void tr(Object... o) {
        if (!oj) System.out.println(Arrays.deepToString(o));
    }
}
