Mike has a sequence A = [a1, a2, ..., an] of length n. He considers the sequence B = [b1, b2, ..., bn] beautiful if the gcd of all its elements is bigger than 1, i.e. <image>. 

Mike wants to change his sequence in order to make it beautiful. In one move he can choose an index i (1 ≤ i < n), delete numbers ai, ai + 1 and put numbers ai - ai + 1, ai + ai + 1 in their place instead, in this order. He wants perform as few operations as possible. Find the minimal number of operations to make sequence A beautiful if it's possible, or tell him that it is impossible to do so.

<image> is the biggest non-negative number d such that d divides bi for every i (1 ≤ i ≤ n).

Input

The first line contains a single integer n (2 ≤ n ≤ 100 000) — length of sequence A.

The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109) — elements of sequence A.

Output

Output on the first line "YES" (without quotes) if it is possible to make sequence A beautiful by performing operations described above, and "NO" (without quotes) otherwise.

If the answer was "YES", output the minimal number of moves needed to make sequence A beautiful.

Examples

Input

2
1 1


Output

YES
1


Input

3
6 2 4


Output

YES
0


Input

2
1 3


Output

YES
1

Note

In the first example you can simply make one move to obtain sequence [0, 2] with <image>.

In the second example the gcd of the sequence is already greater than 1. 
/*
  Editorial *)
Given a sequence v1,v2,- -,vn of zero or one,in one move we can change numbers vi,vi+1 with 2 numbers equal to . vi^vi+1
Find the minimal number of moves to make the whole sequence equal to 0.

It can be proved that it is optimal to solve the task for consecutive ones independently so we divide the array into the minimal
number of subarrays full of ones, if their lengths are s1,s2, .., st,the answer is : 
sigma( ceil(si/2) + si%2) for each from 1 to t.

 another comment *)

In problem C my approach was first you can take gcd of all numbers and check whether it is greater than 1. If not then you can 
greedily check for no of moves required to make all ones by using the property that when there are two odd numbers then you can make 
them even in one move else if there is one odd and one even then you require two moves.

   editorail and comment both produce same result . 
*/
import java.util.*;
import java.io.*;
public class pssss{ 
      
       static int gcd(int a,int b){
                         if(b%a==0) return(a);
                          return gcd(b%a,a);
                   }
      public static void main(String[] args)throws IOException { 
                      PrintWriter out = new PrintWriter(System.out);
                  
                        int n = ni();
                        int g = ni();
                        int ans=0,cnt=0;
                        if((g&1)!=0)cnt++;

                          for(int i=1;i<n;i++){
                                  int x = ni();
                                   g = gcd(g,x);
                                   if((x&1)!=0)cnt++;
                                   else{
                                           ans = ans + cnt/2 + 2*(cnt&1);
                                           cnt=0;
                                   }
                           }
                                 out.println("YES");      
                                     ans = ans + cnt/2 + 2*(cnt&1);
                                if(g>1) out.println("0");
                                else     out.println(ans);

                               out.flush();
                            
    } 
    static FastReader sc=new FastReader(); 
 
      static int ni(){
                 int x = sc.nextInt();
                 return(x);
        }
      static long nl(){
              long x = sc.nextLong();
              return(x);
         }
      static String n(){
                 String str = sc.next();
                     return(str);
       }
     static String ns(){
                 String str = sc.nextLine();
                   return(str);
      }
     static double nd(){
               double d = sc.nextDouble();
                 return(d);
       }
  static class FastReader 
    { 
        BufferedReader br; 
        StringTokenizer st; 
  
        public FastReader() 
        { 
            br = new BufferedReader(new
                     InputStreamReader(System.in)); 
        } 
  
        String next() 
        { 
            while (st == null || !st.hasMoreElements()) 
            { 
                try
                { 
                    st = new StringTokenizer(br.readLine()); 
                } 
                catch (IOException  e) 
                { 
                    e.printStackTrace(); 
                } 
            } 
            return st.nextToken(); 
        } 
  
        int nextInt() 
        { 
            return Integer.parseInt(next()); 
        } 
  
        long nextLong() 
        { 
            return Long.parseLong(next()); 
        } 
  
        double nextDouble() 
        { 
            return Double.parseDouble(next()); 
        } 
  
        String nextLine() 
        { 
            String str = ""; 
            try
            { 
                str = br.readLine(); 
            } 
            catch (IOException e) 
            { 
                e.printStackTrace(); 
            } 
            return str; 
        } 
    } 
}