#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, a, b) for (int i = (a); i < (b); i++)
#ifdef tabr
#include "library/debug.cpp"
#else
#define debug(...) 0
#endif

template <typename T, typename C>
struct mcmf {
    T eps = (T)1e-9;

    struct edge {
        int from;
        int to;
        T c;
        T f;
        C cost;
    };

    vector<vector<int>> g;
    vector<edge> edges;
    vector<C> d;
    vector<int> q;
    vector<bool> in_queue;
    vector<int> pe;
    int n;
    int st, fin;
    T flow;
    C cost;

    mcmf(int _n, int _st, int _fin)
        : n(_n), st(_st), fin(_fin) {
        g.resize(n);
        d.resize(n);
        in_queue.resize(n);
        pe.resize(n);
        flow = 0;
        cost = 0;
    }

    void clear_flow() {
        for (const edge &e : edges) {
            e.f = 0;
        }
        flow = 0;
    }

    void add(int from, int to, T forward_cap, T backward_cap = 0, C cost = 0) {
        g[from].push_back((int)edges.size());
        edges.push_back({from, to, forward_cap, 0, cost});
        g[to].push_back((int)edges.size());
        edges.push_back({to, from, backward_cap, 0, -cost});
    }

    bool expath() {
        fill(d.begin(), d.end(), numeric_limits<C>::max());
        q.clear();
        q.push_back(st);
        d[st] = 0;
        in_queue[st] = true;
        int beg = 0;
        bool found = false;
        while (beg < (int)q.size()) {
            int i = q[beg++];
            if (i == fin) {
                found = true;
            }
            in_queue[i] = false;
            for (int id : g[i]) {
                const edge &e = edges[id];
                if (e.c - e.f > eps && d[i] + e.cost < d[e.to]) {
                    d[e.to] = d[i] + e.cost;
                    pe[e.to] = id;
                    if (!in_queue[e.to]) {
                        q.push_back(e.to);
                        in_queue[e.to] = true;
                    }
                }
            }
        }
        if (found) {
            T push = numeric_limits<T>::max();
            int v = fin;
            while (v != st) {
                const edge &e = edges[pe[v]];
                push = min(push, e.c - e.f);
                v = e.from;
            }
            v = fin;
            while (v != st) {
                edge &e = edges[pe[v]];
                e.f += push;
                edge &back = edges[pe[v] ^ 1];
                back.f -= push;
                v = e.from;
            }
            flow += push;
            cost += push * d[fin];
        }
        return found;
    }

    pair<T, C> max_flow_min_cost() {
        while (expath()) 0;
        return {flow, cost};
    }
};

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n;
    cin >> n;
    ll ans = 0;
    mcmf<ll, int> z(n + 2, 0, n + 1);
    rep(i, 1, n + 1) {
        ll a;
        cin >> a;
        if (a >= 0) {
            z.add(i, n + 1, a);
            ans += a;
        } else {
            z.add(0, i, -a);
        }
    }
    rep(i, 1, n + 1) {
        for (int j = i + i; j <= n; j += i) {
            z.add(i, j, 1e13);
        }
    }
    cout << ans - z.max_flow_min_cost().first << endl;
    return 0;
}

Measured memory_bytes: 384