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.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.InputMismatchException;
	
		 
		public class Solution123 implements Runnable
		{
			static final int MAX = 1000000007;
			static class InputReader
			{
				private InputStream stream;
				private byte[] buf = new byte[1024];
				private int curChar;
				private int numChars;
				private SpaceCharFilter filter;
				private BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		
				public InputReader(InputStream stream)
				{
					this.stream = stream;
				}
				
				public int read()
				{
					if (numChars==-1) 
						throw new InputMismatchException();
					
					if (curChar >= numChars)
					{
						curChar = 0;
						try 
						{
							numChars = stream.read(buf);
						}
						catch (IOException e)
						{
							throw new InputMismatchException();
						}
						
						if(numChars <= 0)				
							return -1;
					}
					return buf[curChar++];
				}
			 
				public String nextLine()
				{
					String str = "";
		            try
		            {
		                str = br.readLine();
		            }
		            catch (IOException e)
		            {
		                e.printStackTrace();
		            }
		            return str;
				}
				public int nextInt()
				{
					int c = read();
					
					while(isSpaceChar(c)) 
						c = read();
					
					int sgn = 1;
					
					if (c == '-') 
					{
						sgn = -1;
						c = read();
					}
					
					int res = 0;
					do 
					{
						if(c<'0'||c>'9') 
							throw new InputMismatchException();
						res *= 10;
						res += c - '0';
						c = read();
					}
					while (!isSpaceChar(c)); 
					
					return res * sgn;
				}
				
				public long nextLong() 
				{
					int c = read();
					while (isSpaceChar(c))
						c = read();
					int sgn = 1;
					if (c == '-') 
					{
						sgn = -1;
						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 res * sgn;
				}
				
				public double nextDouble() 
				{
					int c = read();
					while (isSpaceChar(c))
						c = read();
					int sgn = 1;
					if (c == '-') 
					{
						sgn = -1;
						c = read();
					}
					double res = 0;
					while (!isSpaceChar(c) && c != '.') 
					{
						if (c == 'e' || c == 'E')
							return res * Math.pow(10, nextInt());
						if (c < '0' || c > '9')
							throw new InputMismatchException();
						res *= 10;
						res += c - '0';
						c = read();
					}
					if (c == '.') 
					{
						c = read();
						double m = 1;
						while (!isSpaceChar(c)) 
						{
							if (c == 'e' || c == 'E')
								return res * Math.pow(10, nextInt());
							if (c < '0' || c > '9')
								throw new InputMismatchException();
							m /= 10;
							res += (c - '0') * m;
							c = read();
						}
					}
					return res * sgn;
				}
				
				public String readString() 
				{
					int c = read();
					while (isSpaceChar(c))
						c = read();
					StringBuilder res = new StringBuilder();
					do 
					{
						res.appendCodePoint(c);
						c = read();
					} 
					while (!isSpaceChar(c));
					
					return res.toString();
				}
			 
				public boolean isSpaceChar(int c) 
				{
					if (filter != null)
						return filter.isSpaceChar(c);
					return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
				}
			 
				public String next() 
				{
					return readString();
				}
				
				public interface SpaceCharFilter 
				{
					public boolean isSpaceChar(int ch);
				}
			}
		 	
			public static void main(String args[]) throws Exception
			{
				new Thread(null, new Solution123(),"Solution123",1<<26).start();
			}	
			static long[] ans = new long[1000001];
			static int[] temp;
			static long[][] count = new long[1000001][9];
			static int[] freq;
			static HashSet<Integer> pw2 = new HashSet();
			static ArrayList<Integer> ar[] = new ArrayList[9];
			public void run()

			{
				InputReader sc= new InputReader(System.in);
				PrintWriter w= new PrintWriter(System.out);
				int n = sc.nextInt();
				int z = (int)Math.sqrt(n);
				if(z * z == n){
					w.println(4 * z);
				}else{
					w.println((int)((z + 1) + Math.ceil((n*1.0/(z + 1)))) * 2);
				}
				w.close();
			}
			static class Pair{
				int a;
				int b;
				int c;
				Pair(int a,int b,int c){
					this.a = a;
					this.b = b;
					this.c = c;
				}
			}
		}  