You are given a positive integer n greater or equal to 2. For every pair of integers a and b (2 ≤ |a|, |b| ≤ n), you can transform a into b if and only if there exists an integer x such that 1 < |x| and (a ⋅ x = b or b ⋅ x = a), where |x| denotes the absolute value of x.

After such a transformation, your score increases by |x| points and you are not allowed to transform a into b nor b into a anymore.

Initially, you have a score of 0. You can start at any integer and transform it as many times as you like. What is the maximum score you can achieve?

Input

A single line contains a single integer n (2 ≤ n ≤ 100 000) — the given integer described above.

Output

Print an only integer — the maximum score that can be achieved with the transformations. If it is not possible to perform even a single transformation for all possible starting integers, print 0.

Examples

Input

4


Output

8

Input

6


Output

28

Input

2


Output

0

Note

In the first example, the transformations are 2 → 4 → (-2) → (-4) → 2.

In the third example, it is impossible to perform even a single transformation.
import java.io.*;
import java.util.*;

public class D {

	public static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	public static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));

	public static void main(String[] args) throws IOException {
		readInput();
		out.close();
	}
	
	public static void readInput() throws IOException {
		// br = new BufferedReader(new FileReader(".in"));
		// out = new PrintWriter(new FileWriter(".out"));
		// If this works this is SO fucking cool.
		// Build a graph with a sieve, then DFS down connected components. I will just assume that you can pick up everything connected.
		// within a tour by some euler tour logic given negatives, if i'm wrong i'm wrong. 
		// Going through every possible connection will probably TLE, how to reduce?
		// All primes > n/2 will get fucked. Ignore those.
		// Now, we can use a sieve to add up, and double, also double again for reverse connections (2>4, 4>2). So quad.
		long ans = 0;
		int n = Integer.parseInt(br.readLine());
		for (int i = 2; i <= n/2; i++) {
			long bias = 2;
			for (int j = i*2; j <= n; j+=i) {
				ans += bias*4;
				bias++;
			}
		}
		out.println(ans);
	}
}
