Two people are playing a game with a string s, consisting of lowercase latin letters. 

On a player's turn, he should choose two consecutive equal letters in the string and delete them. 

For example, if the string is equal to "xaax" than there is only one possible turn: delete "aa", so the string will become "xx". A player not able to make a turn loses.

Your task is to determine which player will win if both play optimally.

Input

The only line contains the string s, consisting of lowercase latin letters (1 ≤ |s| ≤ 100 000), where |s| means the length of a string s.

Output

If the first player wins, print "Yes". If the second player wins, print "No".

Examples

Input


abacaba


Output


No


Input


iiq


Output


Yes


Input


abba


Output


No

Note

In the first example the first player is unable to make a turn, so he loses.

In the second example first player turns the string into "q", then second player is unable to move, so he loses.
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {

    public static void main(String[] args) {
        sc.init();
        String s = sc.next();

        DoubleLinkedList<Character> list = new DoubleLinkedList<>();
        for (char c : s.toCharArray()) {
            list.headAdd(c);
        }

        int cnt = 0;

        DoubleLinkedList<Character>.Element here = list.head.next;
        while (here.target != null) {
            if (here.prev.target == here.target) {
                cnt++;
                here.prev.prev.next = here.next;
                here.next.prev = here.prev.prev;
            }
            here = here.next;
        }

        if (cnt % 2 == 0) {
            System.out.println("No");
        } else {
            System.out.println("Yes");
        }
    }
    static class DoubleLinkedList<T> {
        Element head;
        Element tail;
        int size;

        public DoubleLinkedList() {
            head = new Element(null);
            tail = new Element(null);
            head.next = tail;
            tail.prev = head;
        }

        T get(int index) {
            return getElement(index).target;
        }

        T remove(int index) {
            Element ret = getElement(index);
            ret.prev.next = ret.next;
            ret.next.prev = ret.prev;
            size--;
            return ret.target;
        }

        Element getElement(int index) {
            Element ret = head.next;
            for (int i = 0; i < index; i++) {
                ret = ret.next;
            }
            return ret;
        }

        void tailAdd(T target) {
            Element e = new Element(target);
            tail.prev.next = e;
            e.prev = tail.prev;
            e.next = tail;
            tail.prev = e;
            size++;
        }

        void headAdd(T target) {
            Element e = new Element(target);
            head.next.prev = e;
            e.next = head.next;
            e.prev = head;
            head.next = e;
            size++;
        }

        T headPop() {
            T e = head.next.target;
            head.next.next.prev = head;
            head.next = head.next.next;
            size--;
            return e;
        }

        T tailPop() {
            T e = tail.prev.target;
            tail.prev.prev.next = tail;
            tail.prev = tail.prev.prev;
            size--;
            return e;
        }

        class Element {
            T target;
            Element prev;
            Element next;

            private Element(T target) {
                this.target = target;
            }
        }
    }

    static class sc {
        private static BufferedReader br;
        private static StringTokenizer st;

        static void init() {
            br = new BufferedReader(new InputStreamReader(System.in));
            st = new StringTokenizer("");
        }

        static String readLine() {
            try {
                return br.readLine();
            } catch (IOException e) {
            }
            return null;
        }

        static String readLineReplace() {
            try {
                return br.readLine().replaceAll("\\s+", "");
            } catch (IOException e) {
            }
            return null;
        }

        static String next() {
            while (!st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                }
            }
            return st.nextToken();
        }

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

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

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