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.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Map.Entry;
import java.util.Random;
import java.util.Set;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.Vector;


public class Solve {
	static int mod= 1000000007;
	static long [][]ncr ;
	static long temp[];
	static HashMap L,R;

	public static void main(String[] args) throws Exception {
		 PrintWriter out = new PrintWriter(System.out);
		 Scanner sc = new Scanner(System.in);
		int c = 0 ;
		String str =sc.next();
		Stack st = new Stack();
		for(int i=0;i<str.length();i++) {
			if(st.empty()) {
				st.push(str.charAt(i));
			}else {
				char cnt = (char) st.peek();
				if(str.charAt(i)==cnt) {
					st.pop();
					c++;
				}else {
					st.push(str.charAt(i));
				}
			}
		}
		System.out.println(c%2==1?"Yes":"No");
		
			 
			 
			 
			 
			 
			 
			 
		 		 
		 

		 
		 
		 
		 
		
	}
	
	


	private static boolean valid(long x1, long b) {
		int sum =0 ;
		while(x1>0) {
			sum+=x1%10;
			x1/=10;
		}
		return sum==b;
	}




	private static void mergesort(long[] a, int start, int end) {
		 if(end>start) {
			int mid = (start+end)/2;		
			 mergesort(a, start, mid);
			 mergesort(a, mid+1, end);
			 merge(a,start,mid+1,end);
		 
		 
		 }
		
	}




	private static void merge(long[] a, int start, int mid, int end) {
		  int i = start; /* i is index for left subarray*/
	      int j = mid; /* j is index for right subarray*/
	      int k = start; /* k is index for resultant merged subarray*/
	      int t =0 ;
	      while ((i <= mid - 1) && (j <= end)) { 
	            if (a[i] < a[j]) { 
	                temp[k++] = a[i++];
	                long x =0 ;
	                if(R.get(a[i])!=null)
	                	x=(long) R.get(a[i]);
	                R.put(a[i], x+t);
	                
	            } 
	            else {
	            	long x =0 ;
	            	if(L.get(a[j])!=null)
	            		 x =(long) L.get(a[j]);
	            	
	                L.put(a[j],x+ (mid-i));
	                t++;

	                temp[k++] = a[j++];
	            } 
	        }
	      /* Copy the remaining elements of left subarray 
	       (if there are any) to temp*/
	        while (i <= mid - 1) 
	            temp[k++] = a[i++]; 
	  
	        /* Copy the remaining elements of right subarray 
	       (if there are any) to temp*/
	        while (j <= end) 
	            temp[k++] = a[j++]; 
	  
	        /*Copy back the merged elements to original array*/
	        for (i = start; i <= end; i++) 
	            a[i] = temp[i]; 

		
	}




	private static void swap(int i, int j, int[] a) {
		int tmp =a[i];
		a[i]=a[j];
		a[j]=tmp;
		
	}



	private static void ncrbuild(int n, int k) {
		ncr= new long[n+4][k+4];
		for(int i=1;i<=n;i++) {
			for(int j=0; j<=i;j++) {
				if(j==0 ||i==j )
					ncr[i][j]=1L;
				else {
					ncr[i][j]=(ncr[i-1][j-1]%mod+ncr[i-1][j]%mod)%mod;
				}
			}
		}
		
	}
	



	
	

	


}





















	
	
	


class point implements Comparable{
	int x ,y,z;
	point(int x,int y,int z)
	{
		this.x=x;
		this.y=y;
		this.z=z;
	}
	@Override
	public int compareTo(Object arg0) {
		
		point u =((point)arg0);
		
		return -this.z+u.z;
	}
}
 	


	    
	    
	    



class Scanner {
	StringTokenizer st;
	BufferedReader br;

	public Scanner(InputStream s) {
		br = new BufferedReader(new InputStreamReader(s));
	}

	public Scanner(String f) throws FileNotFoundException {
		br = new BufferedReader(new FileReader(f));
	}

	public String next() throws IOException {
		while (st == null || !st.hasMoreTokens())
			st = new StringTokenizer(br.readLine());
		return st.nextToken();
	}

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

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

	public String nextLine() throws IOException {
		return br.readLine();
	}

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

	public boolean ready() throws IOException {
		return br.ready();
	}

	public int[] nextIntArray(int n) throws IOException {
		int[] a = new int[n];
		for (int i = 0; i < n; i++)
			a[i] = nextInt();
		return a;
	}

	public int[] nextIntArray1(int n) throws IOException {
		int[] a = new int[n + 1];
		for (int i = 1; i <= n; i++)
			a[i] = nextInt();
		return a;
	}

	public int[] shuffle(int[] a, int n) {
		int[] b = new int[n];
		for (int i = 0; i < n; i++)
			b[i] = a[i];
		Random r = new Random();
		for (int i = 0; i < n; i++) {
			int j = i + r.nextInt(n - i);
			int t = b[i];
			b[i] = b[j];
			b[j] = t;
		}
		return b;
	}

	public int[] nextIntArraySorted(int n) throws IOException {
		int[] a = nextIntArray(n);
		a = shuffle(a, n);
		Arrays.sort(a);
		return a;
	}

	public long[] nextLongArray(int n) throws IOException {
		long[] a = new long[n];
		for (int i = 0; i < n; i++)
			a[i] = nextLong();
		return a;
	}

	public long[] nextLongArray1(int n) throws IOException {
		long[] a = new long[n + 1];
		for (int i = 1; i <= n; i++)
			a[i] = nextLong();
		return a;
	}

	public long[] nextLongArraySorted(int n) throws IOException {
		long[] a = nextLongArray(n);
		Random r = new Random();
		for (int i = 0; i < n; i++) {
			int j = i + r.nextInt(n - i);
			long t = a[i];
			a[i] = a[j];
			a[j] = t;
		}
		Arrays.sort(a);
		return a;
	}
}