Your security guard friend recently got a new job at a new security company. The company requires him to patrol an area of the city encompassing exactly N city blocks, but they let him choose which blocks. That is, your friend must walk the perimeter of a region whose area is exactly N blocks. Your friend is quite lazy and would like your help to find the shortest possible route that meets the requirements. The city is laid out in a square grid pattern, and is large enough that for the sake of the problem it can be considered infinite.

Input

Input will consist of a single integer N (1 ≤ N ≤ 106), the number of city blocks that must be enclosed by the route.

Output

Print the minimum perimeter that can be achieved.

Examples

Input

4


Output

8


Input

11


Output

14


Input

22


Output

20

Note

Here are some possible shapes for the examples:

<image>
import java.text.DecimalFormat;
import java.util.*;
import java.io.*;
import java.math.*;
 
public class Main {
	public static long mod = (long) (1e9 + 7);
	static InputReader s;
	static PrintWriter out;
	public static void main(String args[]) {
		new Thread(null, new Runnable() {
			public void run() {
				try {
					solve();
					out.flush();
					out.close();
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}, "1", 1 << 26).start();
	}
 
	public static void solve() throws IOException {
		s = new InputReader(System.in);
		OutputStream outputStream = System.out;
		out = new PrintWriter(outputStream);
		Scanner sc = new Scanner(System.in);
		double n = sc.nextDouble();
		out.println((int)(2*Math.ceil(2*Math.sqrt(n))));
	}
	
	
	
	static long combinations(long n, long r) { // O(r)
		if (r == 0 || r == n)
			return 1;
		r = Math.min(r, n - r);
		long ans = n; // nC1=n;
		for (int i = 1; i < r; i++) {
			ans = (ans * (n - i));
			 ans= ans/(i+1);
//			ans = (ans * modulo(i + 1, mod - 2, mod)) % mod;
		}
		return ans;
	}
 
	static long modulo(long x, long y, long p) {
		long res = 1;
		x = x % p;
 
		while (y > 0) {
			if (y % 2 == 1)
				res = (res * x) % p;
 
			y = y >> 1;
			x = (x * x) % p;
		}
		return res;
	}
 
	static HashMap<Integer,Integer> primeFactors(int n) // O(sqrt(n))
	{
		// Print the number of 2s that divide n
		HashMap<Integer,Integer> hm = new HashMap<>();
		while (n % 2 == 0) {
			if(hm.containsKey(2))
				hm.put(2, hm.get(2)+1);
			else
				hm.put(2, 1);
			n = n / 2;
		}
 
		// n must be odd at this point. So we can skip one element (Note i = i
		// +2)
		for (int i = 3; i <= Math.sqrt(n); i = i + 2) {
			// While i divides n, print i and divide n
			while (n % i == 0) {
				if(hm.containsKey(i))
					hm.put(i, hm.get(i)+1);
				else
					hm.put(i, 1);
				n = n / i;
			}
		}
		// This condition is to handle the case when n is a prime number
		// greater than 2
		if (n > 2)
			hm.put(n, 1);
 
		return hm;
	}
 
	public static long expo(long a, long b) {
		if (b == 0)
			return 1;
		if (b == 1)
			return a;
		if (b == 2)
			return a * a;
 
		if (b % 2 == 0) {
			return expo(expo(a, (b / 2)), 2);
		} else {
			return a * expo(expo(a, (b - 1) / 2), 2);
		}
	}
	
	static class Pair implements Comparable<Pair> {
		int a;
		int b;
		Pair(int aa, int bb) {
			a = aa;
			b = bb;
		}
 
		public int compareTo(Pair o) {
			return Integer.compare(this.a, o.a);
		}
 
		public int hashCode() {
			int hu = (int) (a ^ (a >>> 32));
			int hv = (int) (b ^ (b >>> 32));
			return 31 * hu + hv;
		}
 
		public boolean equals(Object o) {
			Pair other = (Pair) o;
			return a == other.a && b == other.b;
		}
 
		public String toString() {
			return "[x=" + a + ", y=" + b + "]";
		}
	}
 
	public static int[] sieve(int N) { // O(n*log(logn))
		int arr[] = new int[N + 1];
		for (int i = 2; i <= Math.sqrt(N); i++) {
			if (arr[i] == 0) {
				for (int j = i * i; j <= N; j = j + i) {
					arr[j] = 1;
				}
			}
		}
		return arr;
		// All the i for which arr[i]==0 are prime numbers.
	}
 
	static long gcd(long a, long b) { // O(logn)
		if (b == 0)
			return a;
		return gcd(b, a % b);
	}
 
	public static void debug(Object... o) {
		System.out.println(Arrays.deepToString(o));
	}
 
	static void catalan_numbers(int n) {
		long catalan[] = new long[n + 1];
		catalan[1] = 1;
		for (int i = 2; i <= n; i++) {
			for (int j = 1; j <= i - 1; j++) {
				catalan[i] = catalan[i] + ((catalan[j]) * catalan[i - j]);
			}
		}
	}
 
	static final class InputReader {
		private final InputStream stream;
		private final byte[] buf = new byte[1024];
		private int curChar;
		private int Chars;
 
		public InputReader(InputStream stream) {
			this.stream = stream;
		}
 
		private int read() throws IOException {
			if (curChar >= Chars) {
				curChar = 0;
				Chars = stream.read(buf);
				if (Chars <= 0)
					return -1;
			}
			return buf[curChar++];
		}
 
		public final int nextInt() throws IOException {
			return (int) nextLong();
		}
 
		public final long nextLong() throws IOException {
			int c = read();
			while (isSpaceChar(c)) {
				c = read();
				if (c == -1)
					throw new IOException();
			}
			boolean negative = false;
			if (c == '-') {
				negative = true;
				c = read();
			}
			long res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += (c - '0');
				c = read();
			} while (!isSpaceChar(c));
			return negative ? (-res) : (res);
		}
 
		public final int[] nextIntBrray(int size) throws IOException {
			int[] arr = new int[size];
			for (int i = 0; i < size; i++)
				arr[i] = nextInt();
			return arr;
		}
 
		public final String next() throws IOException {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.append((char) c);
				c = read();
			} while (!isSpaceChar(c));
			return res.toString();
		}
 
		public final String nextLine() throws IOException {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.append((char) c);
				c = read();
			} while (c != '\n' && c != -1);
			return res.toString();
		}
 
		private boolean isSpaceChar(int c) {
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}
	}
} 