#include <iostream>
#include <set>

using namespace std;

long long mod, N, aa, bb, dbg, dbm, a, b, last, ans, pre, help;
long long t[200001];
int place[200001];
pair<int,long long> g[200001];
pair<int,long long> m[200001];
set<int> szet;

long long gcd(long long x, long long y){
    if(y<x) swap(x,y);
    if(x==0) return y;
    if(y%x==0) return x;
    return gcd(x,y%x);
}

struct pont{
    long long a, b, e;
    pont* bal;
    pont* jobb;
};

pont* fa;

pont* epit(int x, int y){
    pont* p = new pont;
    pont* bf = new pont;
    pont* jf = new pont;
    p->a = x; p->b = y;
    p->e = 0;
    if(x!=y){
        bf = epit(x,(x+y)/2);
        jf = epit((x+y)/2+1,y);
    }
    p->bal = bf;
    p->jobb = jf;
    return p;
}

void be(pont* p){
    if(p->a==p->b){
        p->e = bb;
    } else {
        if(aa<=(p->a+p->b)/2){
            be(p->bal);
        } else {
            be(p->jobb);
        }
        p->e = ((p->bal)->e+(p->jobb)->e)%mod;
    }
}

long long ker(pont* p){
    if(bb<aa) return 0;
    if(aa<=p->a && p->b<=bb) return (p->e)%mod;
    long long a1 = 0;
    long long b1 = 0;
    if(aa<=(p->a+p->b)/2) a1 = ker(p->bal);
    if(bb>(p->a+p->b)/2) b1 = ker(p->jobb);
    return (a1+b1)%mod;
}


int main()
{
    ios_base::sync_with_stdio(false);
    mod = 1000000007;
    cin >> N;
    for(int i=1; i<=N; i++){
        cin >> t[i];
    }

    dbg = 1; dbm = 1;
    fa = epit(1,N);

    for(int i=1; i<=N; i++){
        szet.insert(i);
        a = t[i];
        while(dbm>1 && a>=m[dbm-1].second){
            dbm--;
            aa = m[dbm].first; bb = 0; be(fa);
            szet.erase(m[dbm].first);
        }
        place[i] = dbm;
        m[dbm] = {i,a}; dbm++;

        aa = i; bb = ((i-m[dbm-2].first)*a)%mod; be(fa);

        a = t[i];
        int uj = 0;
        for(int j=1; j<dbg; j++){
            b = gcd(a,g[j].second);
            if(g[uj].second==b){
                g[uj].first = g[j].first;
            } else {
                uj++;
                g[uj].first = g[j].first;
                g[uj].second = b;
            }
        }
        dbg = uj+2;
        g[dbg-1] = {i,a};

        for(int j=dbg-1; j>=1; j--){
            a = g[j-1].first+1; b = g[j].first;
            if((*szet.lower_bound(a))>b){
                help = t[last]*(b-a+1);
                help %= mod;
                help *= g[j].second;
                help %= mod;
                ans += help;
            } else {
                if(j!=dbg-1){
                    pre = m[place[last]-1].first;
                    pre++;
                    help = t[last]*(b-pre+1);
                    help %= mod;
                    help *= g[j].second;
                    help %= mod;
                    ans += help;
                }

                last = (*szet.lower_bound(a));
                help = t[last]*(last-a+1);
                help %= mod;
                help *= g[j].second;
                help %= mod;
                ans += help;

                aa = last+1; bb = b;
                ans += ker(fa);
            }
        }
    }

    cout << ans << endl;

    return 0;
}