#include<bits/stdc++.h>
#define ff first
#define ss second
#define pii pair<int, int>
#define int long long
#define pb push_back
#define eb emplace_back
#define all(x) (x).begin(), (x).end()

using namespace std;
const int maxn = 3e5 + 7, inf = 1e18;
int n;
int cnt[maxn];

struct fenwik {
    int t[maxn];
    int k[maxn];
    vector<int> update;
    int get(int r) {
        int cur = 0;
        for (int i = r; i >= 0; i |= i + 1) {
            cur += t[i];
        }
        return cur;
    }
    int sum(int l, int r) {
        if (l == 0) return get(r);
        return get(r) - get(l - 1);
    }
    void upd(int id, int x) {
        if (k[id] == x) {
            return;
        }
        k[id] = x;
        for (int i = id; i >= 0; i &= i + 1, --i) {
            t[i] += x;
            update.pb(i);
        }
    }
    void clear() {
        for (auto v : update) {
            t[v] = 0;
            k[v] = 0;
        }
    }

};

int len = 1;
vector<int> tree;

void build(int sz) {
    while (len < sz) len <<= 1;
    tree.resize(len + len - 1);
}

int getl(int l, int r, int l1, int r1, int rt, int x) {
    if (max(l, l1) > min(r, r1)) {
        return inf;
    }
    if (l >= l1 && r <= r1) {
        if (tree[rt] > x) {
            return inf;
        }
        if (l == r) {
            return l;
        }
        int t = (l + r) / 2;
        if (tree[rt * 2 + 1] <= x) {
            return getl(l, t, l1, r1, rt * 2 + 1, x);
        }
        return getl(t + 1, r, l1, r1, rt * 2 + 2, x);
    }
    int t = (l + r) / 2;
    int p = getl(l, t, l1, r1, rt * 2 + 1, x);
    if (p != inf) return p;
    return getl(t + 1, r, l1, r1, rt * 2 + 2, x);
}

int getr(int l, int r, int l1, int r1, int rt, int x) {
    if (max(l, l1) > min(r, r1)) {
        return inf;
    }
    if (l >= l1 && r <= r1) {
        if (tree[rt] > x) {
            return inf;
        }
        if (l == r) {
            return l;
        }
        int t = (l + r) / 2;
        if (tree[rt * 2 + 2] <= x) {
            return getr(t + 1, r, l1, r1, rt * 2 + 2, x);
        }
        return getr(l, t, l1, r1, rt * 2 + 1, x);
    }
    int t = (l + r) / 2;
    int p = getr(t + 1, r, l1, r1, rt * 2 + 2, x);
    if (p != inf) return p;
    return getr(l, t, l1, r1, rt * 2 + 1, x);
}

void upd(int l, int r, int l1, int r1, int rt, int x) {
    if (l >= l1 && r <= r1) {
        tree[rt] = x;
        return;
    }
    if (max(l, l1) > min(r, r1)) {
        return;
    }
    int t = (l + r) / 2;
    upd(l, t, l1, r1, rt * 2 + 1, x);
    upd(t + 1, r, l1, r1, rt * 2 + 2, x);
    tree[rt] = min(tree[rt * 2 + 1], tree[rt * 2 + 2]);
}

struct Req {
    int val, id, l, r;
    Req(int a, int b, int c, int d) : val(a), id(b), l(c), r(d) {}
    Req() : val(0), id(0), l(0), r(0) {}
};

vector<Req> have;

vector<pii> left[maxn];
vector<pii> right[maxn];
vector<int> have_all[maxn];

struct Scan {
    int ty, x, val;
    Scan(int a, int b, int c) : ty(a), x(b), val(c) {}
    Scan() : ty(0), x(0), val(0) {}
};

vector<Scan> scan[maxn];

bool cmp(Scan p1, Scan p2) {
    return (p1.x < p2.x) || (p1.x == p2.x && p1.ty < p2.ty);
}

fenwik L, R;

void solve() {
    cin >> n;
    for (int i = 0; i < n; ++i) {
        cin >> cnt[i];
    }
    build(2 * n);
    for (int i = 0; i < n; ++i) {
        upd(0, len - 1, i, i, 0, cnt[i]);
    }
    for (int i = n; i < 2 * n; ++i) {
        upd(0, len - 1, i, i, 0, inf);
    }
    vector<Req> req;
    vector<int> kek;
    for (int i = 0; i < n; ++i) {
        vector<int> idx = {i};
        vector<int> val = {cnt[i]};
        while (true) {
            int p = getl(0, len - 1, idx.back() + 1, len - 1, 0, val.back());
            if (p != inf) {
                val.pb(val.back() % cnt[p]);
                idx.pb(p);
            } else {
                break;
            }
        }
        idx.pb(n);
        for (int j = 0; j < (int)idx.size() - 1; ++j) {
            req.eb(val[j], i, idx[j], idx[j + 1] - 1);
            cout << val[j] << " " << i << " " << idx[j] << " " << idx[j + 1] - 1 << "\n";
            kek.pb(val[j]);
        }
    }
    for (auto v : req) {
        if (v.l) {
            scan[v.val].eb(-1, v.l - 1, v.id);
        }
        scan[v.val].eb(1, v.r, v.id);
    }
    for (int i = 0; i < n; ++i) {
        vector<int> idx = {i};
        vector<int> val = {cnt[i]};
        while (idx[0]) {
            int p = getr(0, len - 1, 0, idx.back() - 1, 0, val.back());
            if (p != inf) {
                val.pb(val.back() % cnt[p]);
                idx.pb(p);
            } else {
                break;
            }
        }
        idx.pb(-1);
        for (int j = 0; j < (int)idx.size() - 1; ++j) {
            have.eb(val[j], i, idx[j + 1] + 1, idx[j]);
            kek.pb(val[j]);
        }
    }
    sort(all(kek));
    kek.erase(unique(all(kek)), kek.end());
    for (auto v : have) {
        int idx = lower_bound(all(kek), v.val) - kek.begin();
        scan[v.val].eb(-2, v.l, v.id);

        scan[v.val].eb(-3, v.r, v.id);

        have_all[idx].eb(v.id);
    }
    for (int i = 0; i < maxn; ++i) {
        sort(all(scan[i]), cmp);
    }
    for (int i = 0; i < maxn; ++i) {
        sort(all(have_all[i]));
    }
    int ans = 0;
    for (int i = 0; i < maxn; ++i) {
        L.clear();
        R.clear();
        for (auto v : scan[i]) {
            if (v.ty == -3) {
                R.upd(v.x, 1);
            } else if (v.ty == -2) {
                L.upd(v.x, 1);
            } else {
                ans += v.ty * L.sum(v.x + 1, maxn - 1);
                ans += v.ty * R.sum(0, v.x - 1);
            }
        }
    }
    cout << ans;
}


signed main() {
    #ifdef HOME
    freopen("input.txt", "r", stdin);
    #else
    ios_base::sync_with_stdio(0); cin.tie(0);
    #endif
    solve();
}