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

public class Div2_410_C {
	public static void main(String args[]) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		
		Solver solver = new Solver();
		solver.solve(in, out);
		out.close();
	}
	
	static class Solver {
		public void solve(InputReader in, PrintWriter out) {
			int n = in.nextInt();
			int first = in.nextInt();
			int second = in.nextInt();
			int[] dp = new int[3];
			int[] b = new int[3];
			out.println("YES");
			int gcd = GCD(first, second);
			if (first % 2 == 0 && second % 2 == 0) {
				dp[0] = 0;
				b[0] = second;
				dp[1] = 0;
				b[1] = second;
			} else if (first % 2 == 1) {
				if ((first - second) % 2 == 0 && (first + second) % 2 == 0) {
					dp[0] = 1;
					dp[1] = 1;
					b[0] = first + second;
					b[1] = first + second;
				} else {
					dp[0] = 2;
					dp[1] = 2;
					b[0] = 2 * first;
					b[1] = 2 * first;
				}
			} else {
				if ((first - second) % 2 == 0 && (first + second) % 2 == 0) {
					dp[0] = 0;
					dp[1] = 1;
					b[0] =  second;
					b[1] = first + second;
				} else {
					dp[0] = 0;
					dp[1] = 2;
					b[0] = second;
					b[1] = 2 * first;
				}
			}
			int j = 2;
			for (int i = 2; i < n; i++) {
				int cur = in.nextInt();
				gcd = GCD(gcd, cur);
				if (cur % 2 == 0) {
					int temp = 0;
					int tempb = 0;
					if (b[j - 2] % 2 == 0) {
						temp = dp[j - 2];
						tempb = cur;
					} else {
						if ((b[j - 2] - cur) % 2 == 0 && (b[j - 2] + cur) % 2 == 0) {
							temp = dp[j - 2] + 1;
							tempb = b[j - 2] + cur;
						} else {
							temp = dp[j - 2] + 2;
							tempb = 2 * b[j - 2];
						}
					}
					if (temp < dp[j - 1]) {
						dp[j] = temp;
						b[j] = tempb;
					} else if (temp > dp[j - 1]) {
						dp[j] = dp[j - 1];
						b[j] = cur;
						} else {
						if (tempb % 2 == 1) {
							dp[j] = temp;
							b[j] = tempb;
						} else {
							dp[j] = dp[j - 1];
							b[j] = cur;
						}
					}
				} else {
					int temp1 = 0;
					int temp1b = 0;
					int temp2 = 0;
					int temp2b = 0;
					if ((b[j - 2] - cur) % 2 == 0 && (b[j - 2] + cur) % 2 == 0) {
						temp1 = dp[j - 2] + 1;
						temp1b = b[j - 2] + cur;
					} else {
						temp1 = dp[j - 2] + 2;
						temp1b = 2 * b[j - 2];
					}
					if ((b[j - 1] - cur) % 2 == 0 && (b[j - 1] + cur) % 2 == 0) {
						temp2 = dp[j - 1] + 1;
						temp2b = b[j - 1] + cur;
					} else {
						temp2 = dp[j - 1] + 2;
						temp2b = 2 * b[j - 1];
					}
					if (temp2 < temp1) {
						dp[j] = temp2;
						b[j] = temp2b;
					} else if (temp2 > temp1) {
						dp[j] = temp1;
						b[j] = temp1b;
					} else {
						if (temp1b % 2 == 1) {
							dp[j] = temp1;
							b[j] = temp1b;
						} else {
							dp[j] = temp2;
							b[j] = temp2b;
						}
					}
				}
				dp[0] = dp[1];
				b[0] = cur;
				dp[1] = dp[2];
				b[1] = b[2];
			}
			if (gcd != 1) {
				out.println(0);
			} else {
				out.println(dp[1]);
			}
		}
		
		public int GCD(int x, int y) {
			while (x % y != 0) {
				int temp = x;
				x = y;
				y = temp % y;
			}
			return y;
		}
	}
	
	static class InputReader {
		BufferedReader reader;
		StringTokenizer tokenizer;
		
		InputReader(InputStream inputStream) {
			reader = new BufferedReader(new InputStreamReader(inputStream));
		}
		
		public String next() {
			while (tokenizer == null || !tokenizer.hasMoreElements()) {
				try {
					tokenizer = new StringTokenizer(reader.readLine());
				} catch (IOException e) {
					throw new RuntimeException(e);
				}
			}
			return tokenizer.nextToken();
		}
		
		public int nextInt() {
			return Integer.parseInt(next());
		}
	}
}