// Original C++ solution (slower):
#ifdef _MSC_VER

#include "stdc++.h"

#endif

#ifdef __GNUC__

#include<bits/stdc++.h>

#endif

using namespace std;



using ll = long long;



//vector

using vi = vector<int>;

using vii = vector<vi>;

using vll = vector<ll>;

using vvll = vector<vll>;



//constant

const double EPS = 1e-10;



#define REP(i, n) for (ll i = 0; i < n; i++)

#define FOR(i, s, e) for (ll i = s; i < e; i++)

#define ALL(x) (x).begin(),(x).end()

#define RALL(x) (x).rbegin(), (x).rend()



//debug

#define DUMP(x)  cerr << #x << " = " << (x) << endl;

#define DEBUG(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << endl;



// vector

//template<typename T> vector<vector<T>> vv(ll H, ll W, T v) { return vector<vector<T>> vec(H, vector<T>(W, v)); }



// view vector

template<typename T> void view(T e) { cout << e << endl; }

template<typename T> void view(const vector<T>& v) { for (const auto& e : v) { cout << e << " "; } cout << endl; }

template<typename T> void view(const vector<vector<T> >& vv) { for (const auto& v : vv) { view(v); } }



// DP

template<class T>bool chmax(T& a, const T& b) { if (a < b) { a = b; return 1; } return 0; }

template<class T>bool chmin(T& a, const T& b) { if (b < a) { a = b; return 1; } return 0; }









// ***************************************



struct Eratos {

    vector<int> primes;

    vector<bool> isprime;

    vector<int> mebius;

    vector<int> min_factor;

 

    Eratos(int MAX) : primes(),

                      isprime(MAX+1, true),

                      mebius(MAX+1, 1),

                      min_factor(MAX+1, -1) {

        isprime[0] = isprime[1] = false;

        min_factor[0] = 0, min_factor[1] = 1;

        for (int i = 2; i <= MAX; ++i) {

            if (!isprime[i]) continue;

            primes.push_back(i);

            mebius[i] = -1;

            min_factor[i] = i;

            for (int j = i*2; j <= MAX; j += i) {

                isprime[j] = false;

                if ((j / i) % i == 0) mebius[j] = 0;

                else mebius[j] = -mebius[j];

                if (min_factor[j] == -1) min_factor[j] = i;

            }

        }

    }

 

    // prime factorization

    vector<pair<int,int>> prime_factors(int n) {

        vector<pair<int,int> > res;

        while (n != 1) {

            int prime = min_factor[n];

            int exp = 0;

            while (min_factor[n] == prime) {

                ++exp;

                n /= prime;

            }

            res.push_back(make_pair(prime, exp));

        }

        return res;

    }

 

    int func(int n) {

        int res = 1;

        while (n != 1) {

            int prime = min_factor[n];

            int exp = 0;

            while (min_factor[n] == prime) {

                ++exp;

                n /= prime;

            }

            res *= exp + 1;

        }

        return res;

    }

};



int main(){



    ll N;

    cin >> N;



    Eratos er = Eratos(N + 1);



    ll ans = 0;

    FOR(k, 1, N + 1){

        ans += k * er.func(k);

    }

    cout << ans << endl;



    return 0;

}


// Optimized solution to the same problem (faster):
#ifdef _MSC_VER

#include "stdc++.h"

#endif

#ifdef __GNUC__

#include<bits/stdc++.h>

#endif

using namespace std;



using ll = long long;



//vector

using vi = vector<int>;

using vii = vector<vi>;

using vll = vector<ll>;

using vvll = vector<vll>;



//constant

const double EPS = 1e-10;



#define REP(i, n) for (ll i = 0; i < n; i++)

#define FOR(i, s, e) for (ll i = s; i < e; i++)

#define ALL(x) (x).begin(),(x).end()

#define RALL(x) (x).rbegin(), (x).rend()



//debug

#define DUMP(x)  cerr << #x << " = " << (x) << endl;

#define DEBUG(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << endl;



// vector

//template<typename T> vector<vector<T>> vv(ll H, ll W, T v) { return vector<vector<T>> vec(H, vector<T>(W, v)); }



// view vector

template<typename T> void view(T e) { cout << e << endl; }

template<typename T> void view(const vector<T>& v) { for (const auto& e : v) { cout << e << " "; } cout << endl; }

template<typename T> void view(const vector<vector<T> >& vv) { for (const auto& v : vv) { view(v); } }



// DP

template<class T>bool chmax(T& a, const T& b) { if (a < b) { a = b; return 1; } return 0; }

template<class T>bool chmin(T& a, const T& b) { if (b < a) { a = b; return 1; } return 0; }









// ***************************************





int main(){



    ll N;

    cin >> N;



    vll A(N + 1, 1);



    FOR(i, 1, N + 1){

        for(ll j = 2; i * j <= N; j++){

            A[i * j]++;

        }

    }



    ll ans = 0;

    FOR(i, 1, N + 1){

        ans += i * A[i];

    }

    cout << ans << endl;



    return 0;

}


// Fastest known solution for this problem: