/****** BISMILLAH HIR RAHMANIR RAHIM ******/

#include <bits/stdc++.h>
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// #include <ext/pb_ds/detail/standard_policies.hpp>

using namespace std;
// using namespace __gnu_pbds;
// using namespace __gnu_cxx;

typedef long long ll;
typedef unsigned int ul;
typedef unsigned long long ull;
typedef vector <int> vi;
typedef map<string,string> mss;
typedef map<int, vector<int> > mvii;
typedef map<int, int> mii;
typedef queue <int> qi;
typedef map <int, vector<string> > mvis;
typedef map <string, vector<int> > mvsi;
typedef vector <string> vs;
typedef pair <int, int> pii;
typedef vector<pair<int,int> > vpii;

// Order Statistic Tree

/* Special functions: 

		find_by_order(k) --> returns iterator to the kth largest element counting from 0
		order_of_key(val) --> returns the number of items in a set that are strictly smaller than our item
*/

// typedef tree<
// int,
// null_type,
// less<int>,
// rb_tree_tag,
// tree_order_statistics_node_update>
// ordered_set;

#define MP make_pair
#define SORT(a) sort (a.begin(), a.end())
#define REVERSE(a) reverse (a.begin(), a.end())
#define ALL(a) a.begin(), a.end()
#define PI acos(-1)
#define ms(x,y) memset (x, y, sizeof (x))
#define INF 2000000000
#define pb push_back
#define MAX 100002
#define debug cout<<"A"<<"\n"
#define prnt(a) cout<<a<<"\n"
#define mod 1000000007LL
#define FOR(i,a,b) for (int i=(a); i<(b); i++)
#define FORr(i,a,b) for (int i=(a); i>=b; i--)
#define itrALL(c,itr) for(__typeof((c).begin()) itr=(c).begin();itr!=(c).end();itr++)
#define lc ((node)<<1)
#define rc ((node)<<1|1)
#define VecPrnt(v) FOR(J,0,v.size()) cout<<v[J]<<" "; cout<<endl
#define endl "\n"
#define PrintPair(x) cout<<x.first<<" "<<x.second<<endl
#define ClearQ(x); while(!x.empty()) x.pop()
#define EPS 1e-9
#define ArrPrint(a,st,en) for(int J=st; J<=en; J++) cout<<a[J]<<" "; cout<<endl;

/* Direction Array */

// int fx[]={1,-1,0,0};
// int fy[]={0,0,1,-1};
// int fx[]={0,0,1,-1,-1,1,-1,1};
// int fy[]={-1,1,0,0,1,1,-1,-1};

template <class T> inline T bigmod(T p,T e,T M)
{
    ll ret = 1;
    for(; e > 0; e >>= 1)
    {
        if(e & 1) ret = (ret * p) % M;
        p = (p * p) % M;
    } return (T)ret;
}

template <class T> inline T gcd(T a,T b){if(b==0)return a;return gcd(b,a%b);}
template <class T> inline T modinverse(T a,T M){return bigmod(a,M-2,M);}
template <class T> inline T lcm(T a,T b) {a=abs(a);b=abs(b); return (a/gcd(a,b))*b;}
template <class T, class X> inline bool getbit(T a, X i) { T t=1; return ((a&(t<<i))>0);}
template <class T, class X> inline T setbit(T a, X i) { T t=1;return (a|(t<<i)); }
template <class T, class X> inline T resetbit(T a, X i) { T t=1;return (a&(~(t<<i)));}

inline ll getnum()
{
    char c = getchar();
    ll num,sign=1;
    for(;c<'0'||c>'9';c=getchar())if(c=='-')sign=-1;
    for(num=0;c>='0'&&c<='9';)
    {
        c-='0';
        num = num*10+c;
        c=getchar();
    }
    return num*sign;
}

inline ll power(ll a, ll b)
{
	ll multiply=1;
	FOR(i,0,b)
	{
		multiply*=a;
	}
	return multiply;
}

/****** END OF HEADER ******/

struct Edge
{
	int to, rev, f, cap;
};


class Dinic
{

public:

	int dist[MAX], q[MAX], work[MAX], src, dest;
	vector<Edge> graph[MAX];
	// MAX equals to node_number

	void init(int sz)
	{
		FOR(i,0,sz+1) graph[i].clear();
	}

	void clearFlow(int sz)
	{
		FOR(i,0,sz+1)
		{
			FOR(j,0,graph[i].size())
				graph[i][j].f=0;
		}
	}

	void addEdge(int s, int t, int cap)
	{
		Edge a={t,(int)graph[t].size(),0,cap};
		Edge b={s,(int)graph[s].size(),0,0};

		// If our graph has bidirectional edges
		// Capacity for the Edge b will equal to cap
		// For directed, it is 0

		graph[s].pb(a);
		graph[t].pb(b);
	}

	bool bfs()
	{
		ms(dist,-1);
		dist[src]=0;
		int qt=0;
		q[qt++]=src;

		for(int qh=0; qh<qt; qh++)
		{
			int u=q[qh];

			for(int j=0; j<graph[u].size(); j++)
			{
				Edge &e=graph[u][j];
				int v=e.to;

				if(dist[v]<0 && e.f<e.cap)
				{
					dist[v]=dist[u]+1;
					q[qt++]=v;
				}
			}
		}

		return dist[dest]>=0;
	}

	int dfs(int u, int f)
	{
		if(u==dest) return f;

		for(int &i=work[u]; i<(int)graph[u].size(); i++)
		{
			Edge &e=graph[u][i];

			if(e.cap<=e.f) continue;

			int v=e.to;

			if(dist[v]==dist[u]+1)
			{
				int df=dfs(v,min(f,e.cap-e.f));

				if(df>0)
				{
					e.f+=df;
					graph[v][e.rev].f-=df;

					return df;
				}
			}
		}

		return 0;
	}

	ll maxFlow(int _src, int _dest)
	{
		src=_src;
		dest=_dest;

		ll result=0;

		while(bfs())
		{
			// debug;
			fill(work,work+MAX,0);
			while(int delta=dfs(src,INF))
				result+=delta;
		}

		return result;
	}
} network;

int n, x;

int main()
{
    // ios_base::sync_with_stdio(0);
    // cin.tie(NULL); cout.tie(NULL);
    // freopen("in.txt","r",stdin);

    int test, cases=1;

    cin>>n;

    ll t=0;

    FOR(i,1,n+1)
    {
    	cin>>x;

    	if(x<0) network.addEdge(0,i,-x);
    	else network.addEdge(i,n+1,x), t+=x;

    	for(int j=2*i; j<=n; j+=i)
    		network.addEdge(i,j,INF);
    }

    ll out=network.maxFlow(0,n+1);

    prnt(t-out);


    return 0;
}



Measured memory_bytes: 3456