#include <bits/stdc++.h>
using namespace std;

template<class T>
struct queue_aggregation {
	using F = function<T(T, T)>;
	using value_type = T;
private : 
	struct node {
		value_type val, sum;
		node (const value_type &val, const value_type &sum) : val(val), sum(sum) { }
	};
	const F f;
	stack<node> front_stack, back_stack;

public : 
	queue_aggregation (const F &f) : f(f), front_stack(), back_stack() { }

	constexpr bool empty () const noexcept {
		return (front_stack.empty() and back_stack.empty());
	}

	constexpr size_t size () const noexcept {
		return (front_stack.size() + back_stack.size());
	}

	void push (const value_type &x) {
		if (back_stack.empty()) {
			back_stack.emplace(x, x);
		} else {
			value_type s = f(back_stack.top().sum, x);
			back_stack.emplace(x, s);
		}
	}

	void pop () {
		assert(not empty());
		if (front_stack.empty()) {
			front_stack.emplace(back_stack.top().val, back_stack.top().val);
			back_stack.pop();
			while (not back_stack.empty()) {
				value_type s = f(back_stack.top().val, front_stack.top().sum);
				front_stack.emplace(back_stack.top().val, s);
				back_stack.pop();
			}
		}
		front_stack.pop();
	}

	value_type fold () {
		assert(not empty());
		if (front_stack.empty()) {
			return (back_stack.top().sum);
		} else if (back_stack.empty()) {
			return (front_stack.top().sum);
		} else {
			return (f(front_stack.top().sum, back_stack.top().sum));
		}
	}

};


int main() {
	int n;
	cin >> n;
	vector<long long> a(n);
	for (int i = 0; i < n; i++) {
		cin >> a[i];
	}
	
	queue_aggregation<long long> que([](long long a, long long b) { return gcd(a, b); });
	
	long long ans = 0;
	for (int l = 0, r = 0; l < n; l++) {
		while ((que.empty() or que.fold() > 1) and r < n) que.push(a[r++]);
		if (not que.empty() and que.fold() == 1) ans += (n - r + 1);
		que.pop();
	}
	
	cout << ans << '\n';
	
	return 0;
}