//#pragma GCC optimize("Ofast,unroll-loops")
//#pragma GCC target("avx2,tune=native")
#include <bits/stdc++.h>
using namespace std;
 
#define file "o"
#define ff(i, a, b) for(auto i=(a); i<=(b); ++i)
#define ffr(i, b, a) for(auto i=(b); i>=(a); --i)
#define nl "\n"
#define ss " "
#define pb emplace_back
#define fi first
#define se second
#define sz(s) (int)s.size()
#define all(s) (s).begin(), (s).end()
#define ms(a,x) memset(a, x, sizeof (a))
#define cn continue
#define re exit(0)
 
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<pii> vpii;
typedef vector<pll> vpll;
 
const int mod=1e9+7;
const int maxn=2e5+15;
const ll inf=4e18;
 
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll ran(ll l, ll r)
{
    return uniform_int_distribution<ll> (l, r)(rng);
}
 
inline void rf(){
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr); cout.tie(nullptr);
    if(fopen(file".inp","r")){
        freopen(file".inp","r",stdin); freopen(file".out","w",stdout);
    }
}
 
template<typename T> inline void add(T &x, const T &y)
{
    x+=y;
    if(x>=mod) x-=mod;
    if(x<0) x+=mod;
}
 
template<typename T> inline bool maxi(T &a, T b)
{
    if(a>=b) return 0;
    a=b; return 1;
}
 
template<typename T> inline bool mini(T &a, T b)
{
    if(a<=b) return 0;
    a=b; return 1;
}
 
 
int main() {
    rf();
 
    int n;
    if (!(cin >> n)) return 0;
    vector<int> a(n);
    for (int i = 0; i < n; ++i) cin >> a[i];
 
    const int MAXV = 200;
    uint64_t base = chrono::high_resolution_clock::now().time_since_epoch().count();
    base ^= 0x9e3779b97f4a7c15ULL;
    base |= 1ULL;
 
    vector<uint64_t> powB(n + 1);
    powB[0] = 1;
    for (int i = 1; i <= n; ++i) powB[i] = powB[i - 1] * base;
 
    auto build = [&](const vector<uint64_t>& v) {
        vector<uint64_t> pref(v.size() + 1);
        for (size_t i = 0; i < v.size(); ++i) pref[i + 1] = pref[i] * base + (v[i] + 1);
        return pref;
    };
    auto subhash = [&](const vector<uint64_t>& pref, int l, int len) {
        return pref[l + len] - pref[l] * powB[len];
    };
 
    vector<long long> G(MAXV + 1), H(MAXV + 1);
 
    for (int d = 1; d <= MAXV; ++d) {
        vector<uint64_t> L(n), R(n);
        for (int i = 0; i < n; ++i) {
            int m = a[i] % d;
            L[i] = m;
            R[i] = (d - m) % d;
        }
        vector<uint64_t> Lrev = L;
        reverse(Lrev.begin(), Lrev.end());
        auto prefL = build(Lrev);
        auto prefR = build(R);
 
        long long gsum = 0;
        for (int i = 0; i < n - 1; ++i) {
            int tMax = min(i + 1, n - (i + 1));
            int revStart = n - 1 - i;
            int lo = 0, hi = tMax;
            while (lo < hi) {
                int mid = (lo + hi + 1) >> 1;
                if (subhash(prefL, revStart, mid) == subhash(prefR, i + 1, mid)) lo = mid;
                else hi = mid - 1;
            }
            gsum += lo;
        }
        G[d] = gsum;
    }
 
    long long ans = 0;
    for (int g = MAXV; g >= 1; --g) {
        long long cnt = G[g];
        for (int m = g * 2; m <= MAXV; m += g) cnt -= H[m];
        H[g] = cnt;
        ans += 1LL * g * H[g];
    }
 
    cout << ans << '\n';
    return 0;
}