#include    <bits/stdc++.h>
#include    <ext/pb_ds/assoc_container.hpp>
#include    <ext/pb_ds/tree_policy.hpp>
using       namespace            std;
using       namespace            __gnu_pbds;
using       ll =                  int64_t ;
using       ull =                 unsigned long long ;
using       ld =                  long double;
#define     int                  int64_t
#define     mem(a,val)           memset( a,  val,  sizeof(a) )
#define     b_s                  binary_search
#define     u_b                  upper_bound
#define     l_b                  lower_bound
#define     nl                   cout<<endl
#define     pb                   push_back
#define     pf                   push_front
#define     FI                   first
#define     SE                   second
#define     ppb                  pop_back
#define     ppf                  pop_front
#define     in                   insert
#define     umap                 unordered_map
#define     pqueue               priority_queue
#define     RR                   return
#define     SZ(X)                ((int)(X).size())
#define     ALL(X)               (X).begin(), (X).end()
#define     BITS(n)              __builtin_popcount(n)
typedef     tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> indexed_set;


/*#include <boost/multiprecision/cpp_int.hpp>
using namespace boost::multiprecision;*/

const int   N =                   1e7 + 7;
const int   MOD =                 (int)1e9 + 7;
const int   MOD1 =                (int)1e9 + 9;
const int   MOD2 =                998244353;
const ld    pi =                  atan2(0, -1);
const ld    eps =                 1e-9;
int         tests =               1;

template<class x, class y>x max(x a, y b) {
	return (a > b) ? a : b;
}
template<class x, class y>x min(x a, y b) {
	return (a < b) ? a : b;
}
template<class x, class y>x log(x n, y r) {
	return (n > r - 1) ? 1 + log(n / r, r) : 0;
}
bool isprime(int n);
bool ispalin(int num);
bool isleapyear(int year);
int __lcm(int a, int b);
int power(int x, int y);
int digitsum(int n);
int fact(int n);
int npr(int n, int r);
int ncr(int n, int r);
int evensum(int n);
int oddsum(int n);
int find_set(int v);
void make_set(int v);
void union_sets(int a, int b);
void sorts(string &str);
struct custom_hash {
	static uint64_t splitmix64(uint64_t x) {
		// http://xorshift.di.unimi.it/splitmix64.c
		x += 0x9e3779b97f4a7c15;
		x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
		x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
		return x ^ (x >> 31);
	}

	size_t operator()(uint64_t x) const {
		static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
		return splitmix64(x + FIXED_RANDOM);
	}
};
///.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.


vector<int> adj[N], subset;
int vis[N];
///.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.
void findDivisors(ll n) 
{ 
    ll divi[n+1];
    memset(divi, 0, sizeof divi); 
    for (ll i = 1; i <= n; i++) { 
    
        for (ll j = 1; j * i <= n; j++) 
            divi[i * j]++; 
    }
    for(ll i=1;i<=n;i++)
    vis[i]=divi[i];
}

int32_t main()
{
	auto start = clock();
	ios_base::sync_with_stdio(0);
	cout.tie(0);
	cin.tie(0);

//	cout<<fixed;
//	cout<<scientific;
//	cout<<fixed<<setprecision(12);
	// cin >> tests;
	for (int test = 1; test <= tests; test++)
	{
//		cout<<"Case #"<<test<<": ";
///.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.


        int n;
        cin>>n;
        findDivisors(n);
        ll ans=0;
        for(ll i=1;i<=n;i++)
        {
            ans+=(i*vis[i]);
        }
        cout<<ans<<endl;














///.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.'.

	}
	cerr << endl << endl << endl << "Time : " << double(clock() - start) / CLOCKS_PER_SEC << endl;
	return 0;
}

























bool isprime(int n)
{
	if (n < 2)
		RR false;
	for (int i = 2; i <= sqrt(n); i++)
	{
		if (n % i == 0)
			return false ;
	}
	return true ;

}

bool ispalin(int num)
{
	bool flag = false;
	int digit, rev = 0, n = num;
	do
	{
		digit = num % 10;
		rev = (rev * 10) + digit;
		num = num / 10;
	} while (num != 0);
	if (rev == n)
		flag = true;
	return flag;
}

bool isleapyear(int year)
{
	if (year % 400 == 0)
		return true;

	if (year % 100 == 0)
		return false;

	if (year % 4 == 0)
		return true;
	return false;
}

int __lcm(int a, int b)
{
	return (a * b) / __gcd(a, b);
}

int power(int x, int y)
{
	int temp;
	if ( y == 0)
		return 1;
	temp = pow(x, y / 2);
	if (y % 2 == 0)
		return temp * temp;
	else
		return x * temp * temp;
}

int digitsum(int n)
{
	int c = 0;
	while (n > 0)
	{
		c++;
		n /= 10;
	}
	return c;
}

int fact(int n)
{
	if (n <= 1)
		return 1;
	return n * fact(n - 1);
}

int ncr(int n, int r)
{
	long long p = 1, k = 1;
	if (n - r < r)
		r = n - r;

	if (r != 0) {
		while (r) {
			p *= n;
			k *= r;
			int m = __gcd(p, k);
			p /= m;
			k /= m;
			n--;
			r--;
		}
	}
	else
		p = 1;
	return p;
}

int npr(int n, int r)
{
	return fact(n) / fact(n - r);
}

int evensum(int n)
{
	return (n / 2 * (n / 2 + 1));
}

int oddsum(int n)
{
	return (((n + 1) / 2) * ((n + 1) / 2));
}

void sorts(string &str)
{
	sort(str.begin(), str.end());
}


Measured memory_bytes: 394332