You have an array a with length n, you can perform operations. Each operation is like this: choose two adjacent elements from a, say x and y, and replace one of them with gcd(x, y), where gcd denotes the [greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor).

What is the minimum number of operations you need to make all of the elements equal to 1?

Input

The first line of the input contains one integer n (1 ≤ n ≤ 2000) — the number of elements in the array.

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

Output

Print -1, if it is impossible to turn all numbers to 1. Otherwise, print the minimum number of operations needed to make all numbers equal to 1.

Examples

Input

5
2 2 3 4 6


Output

5


Input

4
2 4 6 8


Output

-1


Input

3
2 6 9


Output

4

Note

In the first sample you can turn all numbers to 1 using the following 5 moves:

  * [2, 2, 3, 4, 6]. 
  * [2, 1, 3, 4, 6]
  * [2, 1, 3, 1, 6]
  * [2, 1, 1, 1, 6]
  * [1, 1, 1, 1, 6]
  * [1, 1, 1, 1, 1]



We can prove that in this case it is not possible to make all numbers one using less than 5 moves.

import java.io.InputStream;
import java.io.PrintStream;
import java.util.Arrays;
import java.util.Scanner;

/**
 */
public class Main892C {
	public static void main(String[] args) {
		run(System.in, System.out);
	}

	public static void run(InputStream in, PrintStream out) {

		try (Scanner sc = new Scanner(in)) {
			int n = sc.nextInt();
			if (n == 1) {
				int a = sc.nextInt();
				out.print(a == 1 ? "0" : "-1");
				return;
			}

			int[] t = new int[n];
			int nbOfOnes = 0;
			for (int i = 0; i < n; i++) {
				t[i] = sc.nextInt();
				if (t[i] == 1) nbOfOnes++;
			}

			if (nbOfOnes > 0) {
				out.print(n - nbOfOnes);
				return;
			}

			// Check if possible
			int gcd = gcd(t[0], t[1]);
			for (int i = 2; i < n; i++)
				gcd = gcd(gcd, t[i]);
			if (gcd != 1) {
				out.print("-1");
				return;
			}

		
			int bestSeg = Integer.MAX_VALUE;
			for(int i = 0; i<n-1; i++) {
				//System.err.println("Gcd of " + t[i] + " & " + t[i+1] + "=" + gcd(t[i], t[i+1]));

				int g = gcd(t[i], t[i+1]);
				if (g == 1) {
					bestSeg = 1;
					break;
				}
				for (int j = i+2; j < n; j++) {
					//System.err.println("Gcd of " + g + " & " + t[j] + "=" + gcd(g, t[j]));
					g = gcd(g, t[j]);
					if (g == 1 && j-i < bestSeg) {
						//System.err.println("Using " + Arrays.toString(Arrays.copyOfRange(t, i, j + 1)));
						bestSeg = j-i;
						break;
					}
					
				}
				//System.err.println("Swapping " + best);
				//System.err.println(Arrays.toString(t));
			}
			out.print(bestSeg + n - 1);
		}
	}

	static int gcd(int a, int b) {
		if (b > a) return gcd(b, a);
		while (a != 0 && b != 0) {
			int c = b;
			b = a % b;
			a = c;
		}
		return a + b; // either one is 0, so return the non-zero value
	}

}