#include <bits/stdc++.h>
using namespace std;
//#define DEBUG_MODE
#define endl '\n'
#ifdef DEBUG_MODE
#define DEBUG(X) debug_func(X, #X)
#define DEBUG_ENDL endl << flush
#define DEBUG_SEPARATOR_LINE cout<<"=================\n"
#else
#define DEBUG(X) 0
#define DEBUG_ENDL 0
#define DEBUG_SEPARATOR_LINE 0
#endif
#define ALL(V) (V).begin(), (V).end()
#define ALLR(V) (V).rbegin(), (V).rend()
#define DEBUG_ENDL_S(S) ((S).size() ? "\n" : "") << flush;
template <typename T> using V = vector<T>;
template <typename T> using VV = V<V<T>>;
template <typename T, typename U> using P = pair<T, U>;
using ll = int64_t;
using PLL = P<ll, ll>;
template <typename T> const T& var_min(const T &t) { return t; }
template <typename T> const T& var_max(const T &t) { return t; }
template <typename Head, typename... Tail> const Head& var_min(const Head &head, const Tail&... tail) { return min(head, var_min(tail...)); }
template <typename Head, typename... Tail> const Head& var_max(const Head &head, const Tail&... tail) { return max(head, var_max(tail...)); }
template <typename T, typename... Tail> void chmin(T &t, const Tail&... tail) { t = var_min(t, tail...); }
template <typename T, typename... Tail> void chmax(T &t, const Tail&... tail) { t = var_max(t, tail...); }
void debug_func_preffix(const string &s) { if(s.size()) cout << s << " = "; }
template <typename T>
void debug_func(const T &t, const string &s = "") {
    debug_func_preffix(s);
    cout << t << DEBUG_ENDL_S(s);
}
template <typename T, typename U>
void debug_func(const P<T, U> &p, const string &s = "") {
    debug_func_preffix(s);
    cout << "(";
    debug_func(p.first);
    cout << ", ";
    debug_func(p.second);
    cout << ")" << DEBUG_ENDL_S(s);
}
template <typename T>
void debug_func(const V<T> &v, const string &s = "") {
    for(ll i = 0; i < v.size(); i++) {
        string t = s + "[" + to_string(i) + "]";
        debug_func(v[i], t);
    }
}

void init_io() {
    cin.tie(0);
    ios_base::sync_with_stdio(false);
    cout << fixed << setprecision(30);
}

class FordFulkerson {
    struct Edge {
        ll to, cap, rev_index;
    };
    vector<vector<Edge>> v;
    ll n;
    bool *used;
    const ll INF = numeric_limits<ll>::max();

    int dfs(ll now, ll goal, ll f) {
        if(now == goal) return f;
        used[now] = 1;
        for(Edge &e : v[now]) {
            if(used[e.to]) {
                continue;
            }
            if(e.cap <= 0) {
                continue;
            }
            ll d = dfs(e.to, goal, min(f, e.cap));
            if(d > 0) {
                e.cap -= d;
                v[e.to][e.rev_index].cap += d;
                return d;
            }
        }
        return 0;
    }

public:
    FordFulkerson(const vector<vector<pair<ll, ll>>> &v) {
        this->n = v.size();
        for(int i = 0; i < n; i++) {
            this->v.push_back(vector<Edge>(0));
        }
        for(int i = 0; i < n; i++) {
            for(auto e : v[i]) {
                this->v[i].push_back((Edge) {e.first, e.second, (ll)this->v[e.first].size()} );
                this->v[e.first].push_back((Edge) {i, 0, (ll)this->v[i].size() - 1} );
            }
        }
        used = new bool[n];
    }

    ll max_flow(ll start, ll goal) {
        ll ret = 0;
        while(1) {
            memset(used, 0, n);
            ll add = dfs(start, goal, INF);
            if(add == 0) {
                return ret;
            }
            ret += add;
        }
    }
};

const ll INF = 5e15;

int main() {
    init_io();
    ll N;
    cin >> N;
    V<ll> A(N);
    ll sum = 0;
    for(ll &e : A) {
        cin >> e;
        sum += max<ll>(0, e);
    }
    ll start = 0, goal = N + 1;
    VV<PLL> edges(goal + 1);
    for(ll i = 1; i <= N; i++) {
        ll val = A[i - 1];
        if(val < 0) edges[start].emplace_back(i, -val);
        else edges[i].emplace_back(goal, val);
        for(ll j = 2; i * j <= N; j++) edges[i].emplace_back(i * j, INF);
    }
    FordFulkerson ff(edges);
    ll cost = ff.max_flow(start, goal);
    DEBUG(cost);
    cout << sum - cost << endl;
    return 0;
}


Measured memory_bytes: 384