#include <iostream>
#include <algorithm>
using namespace std;

long long n, ans, c[10000001];

int main()
{
	cin >> n;

	for (int i = 1; i <= n; ++i)
	{
		for (int j = 0; (j += i) <= n; )
		{
			c[j]++;
		}
	}

	for (int i = 1; i <= n; i++)
	{
		ans += (long long) i * c[i];
	}

	cout << ans << endl;
}

/*
#include <iostream>
#include <algorithm>
#include <vector>
#include <utility>
#include <chrono>
using namespace std;

long long n, ans;

/*
long long div_cnt(long long num)
{
	/*
	vector<int> pf;
	int temp = num, ans = 1;
	for (int i = 2; i <= temp; i++)
	{
		if (!(temp % i))
		{
			int x = temp / i;
			pf.push_back(x + 1);
			temp /= i;
		}
	}

	for (int j = 0; j < pf.size(); j++)
	{
		ans *= pf[j];
	}

	return ans;
	

	long long div = 1;
	vector<long long> pf;
	for (long long i = 2; i <= num && num > 1; i++)
	{
		if (!(num % i))
		{
			long long x = 0;
			while (!(num % i))
			{
				num /= i;
				x++;
			}

			pf.push_back(x + 1);
		}
	}

	for (long long j = 0; j < pf.size(); j++)
	{
		div *= pf[j];
	}
	
	return div;
}


void SieveOfEratosthenes(long long n, bool prime[],
	bool primesquare[], long long a[])
{
	// Create a boolean array "prime[0..n]" and 
	// initialize all entries it as true. A value 
	// in prime[i] will finally be false if i is 
	// Not a prime, else true. 
	for (long long i = 2; i <= n; i++)
		prime[i] = true;

	// Create a boolean array "primesquare[0..n*n+1]" 
	// and initialize all entries it as false. A value 
	// in squareprime[i] will finally be true if i is 
	// square of prime, else false. 
	for (long long i = 0; i <= (n * n + 1); i++)
		primesquare[i] = false;

	// 1 is not a prime number 
	prime[1] = false;

	for (long long p = 2; p * p <= n; p++) {
		// If prime[p] is not changed, then 
		// it is a prime 
		if (prime[p] == true) {
			// Update all multiples of p 
			for (long long i = p * 2; i <= n; i += p)
				prime[i] = false;
		}
	}

	long long j = 0;
	for (long long p = 2; p <= n; p++) {
		if (prime[p]) {
			// Storing primes in an array 
			a[j] = p;

			// Update value in primesquare[p*p], 
			// if p is prime. 
			primesquare[p * p] = true;
			j++;
		}
	}
}

// Function to count divisors 
long long countDivisors(long long n)
{
	// If number is 1, then it will have only 1 
	// as a factor. So, total factors will be 1. 
	if (n == 1)
		return 1;

	bool prime[10000001], primesquare[100000000000001]; //-- prime[n + 1], primesquare[n * n + 1]

	long long a[10000000]; // for storing primes upto n-- a[n]

	// Calling SieveOfEratosthenes to store prime 
	// factors of n and to store square of prime 
	// factors of n 
	SieveOfEratosthenes(n, prime, primesquare, a);

	// ans will contain total number of distinct 
	// divisors 
	long long ans = 1;

	// Loop for counting factors of n 
	for (long long i = 0;; i++) {
		// a[i] is not less than cube root n 
		if (a[i] * a[i] * a[i] > n)
			break;

		// Calculating power of a[i] in n. 
		long long cnt = 1; // cnt is power of prime a[i] in n. 
		while (n % a[i] == 0) // if a[i] is a factor of n 
		{
			n = n / a[i];
			cnt = cnt + 1; // incrementing power 
		}

		// Calculating number of divisors 
		// If n = a^p * b^q then total divisors of n 
		// are (p+1)*(q+1) 
		ans = ans * cnt;
	}

	// if a[i] is greater than cube root of n 

	// First case 
	if (prime[n])
		ans = ans * 2;

	// Second case 
	else if (primesquare[n])
		ans = ans * 3;

	// Third casse 
	else if (n != 1)
		ans = ans * 4;

	return ans; // Total divisors 
}


int main()
{
	cin >> n;

	for (long long i = 2; i <= n; i++)
	{
		ans += (i * countDivisors(i));
	}

	cout << ans + 1 << endl;
}
*/

Measured memory_bytes: 81732