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.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Iterator;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.io.BufferedReader;
import java.util.NoSuchElementException;
import java.io.InputStream;

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

    static class TaskB {
        public void solve(int testNumber, MyInputReader in, PrintWriter out) {
            char[] s = in.next().toCharArray();
            Stack<Character> chars = new Stack<>();

            int ans = 0;
            for (int i = 0; i < s.length; i++) {
                char actual = s[i];
                if (chars.size() > 0 && chars.peek() == actual) {
                    ans++;
                    chars.pop();
                } else chars.push(actual);
            }

            if (ans % 2 == 1) {
                out.println("Yes");
            } else {
                out.println("No");
            }
        }

    }

    static class Stack<Item> implements Iterable<Item> {
        private Stack.Node<Item> first;
        private int n;

        public Stack() {
            first = null;
            n = 0;
        }

        public boolean isEmpty() {
            return first == null;
        }

        public int size() {
            return n;
        }

        public void push(Item item) {
            Stack.Node<Item> oldfirst = first;
            first = new Stack.Node<Item>();
            first.item = item;
            first.next = oldfirst;
            n++;
        }

        public Item pop() {
            if (isEmpty()) throw new NoSuchElementException("Stack underflow");
            Item item = first.item;        // save item to return
            first = first.next;            // delete first node
            n--;
            return item;                   // return the saved item
        }

        public Item peek() {
            if (isEmpty()) throw new NoSuchElementException("Stack underflow");
            return first.item;
        }

        public String toString() {
            StringBuilder s = new StringBuilder();
            for (Item item : this) {
                s.append(item);
                s.append(' ');
            }
            return s.toString();
        }

        public Iterator<Item> iterator() {
            return new ListIterator<Item>(first);
        }

        private static class Node<Item> {
            private Item item;
            private Stack.Node<Item> next;

        }

        private class ListIterator<Item> implements Iterator<Item> {
            private Stack.Node<Item> current;

            public ListIterator(Stack.Node<Item> first) {
                current = first;
            }

            public boolean hasNext() {
                return current != null;
            }

            public void remove() {
                throw new UnsupportedOperationException();
            }

            public Item next() {
                if (!hasNext()) throw new NoSuchElementException();
                Item item = current.item;
                current = current.next;
                return item;
            }

        }

    }

    static class MyInputReader {
        private BufferedReader reader;
        private StringTokenizer tokenizer;

        public MyInputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    String l = reader.readLine();
                    if (l == null) throw new RuntimeException("asd");
                    tokenizer = new StringTokenizer(l);
                } catch (Exception e) {
                    //return null;
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

    }
}
