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.*;
import java.math.*;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.*;
import javax.print.attribute.SetOfIntegerSyntax;

    public class Main {
        private static InputStream stream;
        private static byte[] buf = new byte[1024];
        private static int curChar;
        private static int numChars;
        private static SpaceCharFilter filter;
        private static PrintWriter pw;
        private static long count = 0,mod=1000000007,max=0;
        private static TreeSet<Integer>ts[]=new TreeSet[200000];
     
        public static void main(String args[]) throws Exception {
            InputReader(System.in);
            pw = new PrintWriter(System.out); 
            new Thread(null ,new Runnable(){
               public void run(){
                   try{
                       soln();
                       pw.close();
                   } catch(Exception e){
                       e.printStackTrace();
                   }
               }
           },"1",1<<26).start();
        }
        //----------------------------------------My Code------------------------------------------------//
        public static class Participant implements Comparable<Participant>{
            String name;
            int score;
            Participant(String s, int n){
                this.name=s;
                this.score=n;
            }
            @Override
            public int compareTo(Participant o){
                if(o.score<score){
                    return 1;
                }
                else if(o.name.equals(this.name)) return 0;
                else{
                    return -1;
                }
            }
            @Override
            public boolean equals(Object obj){
                if(obj==null) return false;
                if(obj.getClass()!=this.getClass()) return false;
                Participant prt=(Participant) obj;
                if(this.name.equals(prt.name)) return true;
                return false;
            }
            @Override
            public int hashCode(){
                return this.name.hashCode();
            }
        }
        public static class Comp<T> implements Comparator<Participant>{
            @Override
            public int compare(Participant p1, Participant p2) {    
                if(p1.score<p2.score) return 1;
                else
                return 0;
            }
        }
        
        private static void soln() {
        	int n=nextInt();
        	int i=1;
        	for(;;i++){
        		if((i*i)>=n){
        			if((i*i)>n){
        				i--;
        				break;
        			}
        			else{
        				pw.println(4*i);
        				return ;
        			}
        			
        		}
        		
        	}
        	n-=(i*i);
        	int x=i;
        	while(true){
        		n-=i;
        		x++;
        		if(n<=0){
        			pw.println(2*(x+i));
        			return ;
        		}
        	}
        }
       
        static int ver=-1;
        private static void dfs(int root,LinkedList<Integer>[] adj,boolean[] visited){
        	visited[root]=true;
        	boolean flag=false;
        	for(int x:adj[root]){
        		if(!visited[x]){
        			count++;
        			//pw.println(count+" after incr at node " +root);
        			dfs(x,adj,visited);
        			flag=true;
        			//pw.println(count+" at node "+root);
        		}
        	}
        	if(!flag) {
        		long prev=max;
        		max=Math.max(count, max);
        		if(prev!=max){
        			ver=root;
        			//arr[root]=(int)Math.max(arr[root], max);
        		}
        	}
        	count--;
        	
        	visited[root]=false;
        }
        public static int fact(int n){
            int ans=1;
            for(int i=1;i<=n;i++) ans=(ans*i)%1000000007;
            return ans;
        }
        //----------------------------------------THE END----------------------------------------------------------//            
     
        static class Pair implements Comparable<Pair>{
     
           int a,b;
            Pair(int idx,int k){
                this.a=idx;
                this.b=k;
                //this.l=l;
            }
            @Override
            public int compareTo(Pair o) {
               if(a>o.a){
            	   return -1;
               }
               else if(a==o.a){
            	   return 0;
               }
               else{
            	   return 1;
               }
               
                
            }
           
        }
     
        public static long gcd(long x, long y) {
            if (x % y == 0)
                return y;
            else
                return gcd(y, x % y);
        }
        
        private static int BinarySearch(int a[], int low, int high, int target) {
            if (low > high)
                return -1;
            int mid = low + (high - low) / 2;
            if (a[mid] == target)
                return mid;
            if (a[mid] > target)
                high = mid - 1;
            if (a[mid] < target)
                low = mid + 1;
            return BinarySearch(a, low, high, target);
        }
        
        public static String reverseString(String s) {
            StringBuilder sb = new StringBuilder(s);
            sb.reverse();
            return (sb.toString());
        }
     
        
        
        public static long pow(long n, long p, long m) {
            long result = 1;
            if (p == 0)
                return 1;
            if (p == 1)
                return n;
            while (p != 0) {
                if (p % 2 == 1)
                    result *= n;
                if (result >= m)
                    result %= m;
                p >>= 1;
                n *= n;
                if (n >= m)
                    n %= m;
            }
            return result;
        }
     
        public static long pow(long n, long p) {
            long result = 1;
            if (p == 0)
                return 1;
            if (p == 1)
                return n;
            while (p != 0) {
                if (p % 2 == 1)
                    result *= n;
                p >>= 1;
                n *= n;
            }
            return result;
     
        }
     
         public static int[] radixSort(int[] f) {
            int[] to = new int[f.length];
            {
                int[] b = new int[65537];
                for (int i = 0; i < f.length; i++)
                    b[1 + (f[i] & 0xffff)]++;
                for (int i = 1; i <= 65536; i++)
                    b[i] += b[i - 1];
                for (int i = 0; i < f.length; i++)
                    to[b[f[i] & 0xffff]++] = f[i];
                int[] d = f;
                f = to;
                to = d;
            }
            {
                int[] b = new int[65537];
                for (int i = 0; i < f.length; i++)
                    b[1 + (f[i] >>> 16)]++;
                for (int i = 1; i <= 65536; i++)
                    b[i] += b[i - 1];
                for (int i = 0; i < f.length; i++)
                    to[b[f[i] >>> 16]++] = f[i];
                int[] d = f;
                f = to;
                to = d;
            }
            return f;
        }
     
        public static int nextPowerOf2(final int a) {
            int b = 1;
            while (b < a) {
                b = b << 1;
            }
            return b;
        }
     
        public static boolean PointInTriangle(int p1, int p2, int p3, int p4, int p5, int p6, int p7, int p8) {
            int s = p2 * p5 - p1 * p6 + (p6 - p2) * p7 + (p1 - p5) * p8;
            int t = p1 * p4 - p2 * p3 + (p2 - p4) * p7 + (p3 - p1) * p8;
     
            if ((s < 0) != (t < 0))
                return false;
     
            int A = -p4 * p5 + p2 * (p5 - p3) + p1 * (p4 - p6) + p3 * p6;
            if (A < 0.0) {
                s = -s;
                t = -t;
                A = -A;
            }
            return s > 0 && t > 0 && (s + t) <= A;
        }
     
        public static float area(int x1, int y1, int x2, int y2, int x3, int y3) {
            return (float) Math.abs((x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2)) / 2.0);
        }
     
        public static boolean isPrime(int n) {
            // Corner cases
            if (n <= 1)
                return false;
            if (n <= 3)
                return true;
     
            // This is checked so that we can skip 
            // middle five numbers in below loop
            if (n % 2 == 0 || n % 3 == 0)
                return false;
     
            for (int i = 5; i * i <= n; i = i + 6)
                if (n % i == 0 || n % (i + 2) == 0)
                    return false;
     
            return true;
        }
     
        //merge Sort
     
        static long sort(int a[])
        {  int n=a.length;
            int b[]=new int[n];    
            return mergeSort(a,b,0,n-1);}
        static long mergeSort(int a[],int b[],long left,long right)
        { long c=0;if(left<right)
         {   long mid=left+(right-left)/2;
             c= mergeSort(a,b,left,mid);
             c+=mergeSort(a,b,mid+1,right);
             c+=merge(a,b,left,mid+1,right); }    
            return c;     }
        static long merge(int a[],int  b[],long left,long mid,long right)
        {long c=0;int i=(int)left;int j=(int)mid; int k=(int)left;
        while(i<=(int)mid-1&&j<=(int)right)
        { if(a[i]>a[j]) {b[k++]=a[i++]; }
        else    { b[k++]=a[j++];c+=mid-i;}}
        while (i <= (int)mid - 1)   b[k++] = a[i++]; 
        while (j <= (int)right) b[k++] = a[j++];
        for (i=(int)left; i <= (int)right; i++) 
            a[i] = b[i];  return c;  }
     
        // To Get Input
        // Some Buffer Methods
     
        public static void InputReader(InputStream stream1) {
            stream = stream1;
        }
     
        private static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }
     
        private static boolean isEndOfLine(int c) {
            return c == '\n' || c == '\r' || c == -1;
        }
     
        private static 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++];
        }
     
        private static 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;
        }
     
        private static 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;
        }
     
        private static String nextToken() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isSpaceChar(c));
            return res.toString();
        }
     
        private static String nextLine() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isEndOfLine(c));
            return res.toString();
        }
     
        private static int[] nextIntArray(int n) {
            int[] arr = new int[n];
            for (int i = 0; i < n; i++) {
                arr[i] = nextInt();
            }
            return arr;
        }
     
        private static int[][] next2dArray(int n, int m) {
            int[][] arr = new int[n][m];
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                    arr[i][j] = nextInt();
                }
            }
            return arr;
        }
     
        private static long[] nextLongArray(int n) {
            long[] arr = new long[n];
            for (int i = 0; i < n; i++) {
                arr[i] = nextLong();
            }
            return arr;
        }
     
        private static void pArray(int[] arr) {
            for (int i = 0; i < arr.length; i++) {
                pw.print(arr[i] + " ");
            }
            pw.println();
            return;
        }
     
        private static void pArray(long[] arr) {
            for (int i = 0; i < arr.length; i++) {
                pw.print(arr[i] + " ");
            }
            pw.println();
            return;
        }
     
        private static void pArray(boolean[] arr) {
            for (int i = 0; i < arr.length; i++) {
                pw.print(arr[i] + " ");
            }
            pw.println();
            return;
        }
     
        private static boolean isSpaceChar(int c) {
            if (filter != null)
                return filter.isSpaceChar(c);
            return isWhitespace(c);
        }
     
        private interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);
        }
            
            
        }