[3R2 - Standby for Action](https://www.youtube.com/watch?v=P2ZVC9aoiKo)

Our dear Cafe's owner, JOE Miller, will soon take part in a new game TV-show "1 vs. n"!

The game goes in rounds, where in each round the host asks JOE and his opponents a common question. All participants failing to answer are eliminated. The show ends when only JOE remains (we assume that JOE never answers a question wrong!).

For each question JOE answers, if there are s (s > 0) opponents remaining and t (0 ≤ t ≤ s) of them make a mistake on it, JOE receives \displaystylet/s dollars, and consequently there will be s - t opponents left for the next question.

JOE wonders what is the maximum possible reward he can receive in the best possible scenario. Yet he has little time before show starts, so can you help him answering it instead?

Input

The first and single line contains a single integer n (1 ≤ n ≤ 10^5), denoting the number of JOE's opponents in the show.

Output

Print a number denoting the maximum prize (in dollars) JOE could have.

Your answer will be considered correct if it's absolute or relative error won't exceed 10^{-4}. In other words, if your answer is a and the jury answer is b, then it must hold that (|a - b|)/(max(1, b)) ≤ 10^{-4}.

Examples

Input


1


Output


1.000000000000


Input


2


Output


1.500000000000

Note

In the second example, the best scenario would be: one contestant fails at the first question, the other fails at the next one. The total reward will be \displaystyle 1/2 + 1/1 = 1.5 dollars.
// package Jobeel;
import java.util.*;
import java.io.*;
import java.lang.*;
import java.math.*;
import java.util.Map.*;
public class codeforces {
      public static void main(String [] args) throws IOException, InterruptedException {
	    InputReader sc=new InputReader(System.in);
    	int t=sc.nextInt();
    	pw.print(sum(t));
	    pw.flush();
		pw.close();
	}
      static double sum(int n) 
      { 
        double i, s = 0.0; 
        for (i = 1; i <= n; i++) 
            s = s + 1/i; 
        return s; 
      } 
    static int [] size,arr;
  	static int inv;
  	static long M=(long)1e9+9,P=999983;
  	static HashSet<StringBuilder> set_1;
  	static TreeSet<Long> set; 
  	
  	static int fix(int a,int k) {          // turn -% to +%
  		return (a%k+k)%k;
  	}
      static void solveBruteForece(int index , int mask) {
  		if(index==arr.length) {
  			long sum=0;
  			for(int i=0;i<arr.length;i++) {
  				if((mask & 1<<i)!=0) sum+=arr[i];
  				
  			}
  			set.add(sum);
  			return;
  		}
  		solveBruteForece(index+1,mask | 1<<index);
  		solveBruteForece(index+1,mask);
  	}
  	public static int find(int i) {
  		if(arr[i]==i) return i;
  		else {
  			int result=find(arr[i]);
  			arr[i]=result;
  			return result;
  		}
  	}
  public static void union(int u,int v) {
  		int root_u=find(u);
  		int root_v=find(v);
  		if (root_u==root_v) return;
  		else if(size[root_u]>size[root_v]) {
  			size[root_u]+=size[root_v];
  			arr[root_v]=root_u;
  		}else  {
  			size[root_v]+=size[root_u];
  			arr[root_u]=root_v;
  		}
  	}
      static int search(int x,int [] arr) {
      	int low=0,high=arr.length-1,ans=-1;
      	while(low<=high) {
      		int mid=(low+high)>>1;
      	   if(arr[mid]==x) { ans=mid; break;}
      	   else if(arr[mid]>x) high=mid-1;
      	   else low=mid+1;
      	}
      	return ans;
      }
     static  long gcd(long a, long b) 
      { 
          if (b == 0) 
              return a; 
          return gcd(b, a % b);  
            
      } 
     public static long largestDivisor(long n){
  	   long divisor = 0;
  	   long  w=n>>1;
  	   for (int i = 1; i <= w; i++)
  	       if (n % i == 0) 
  	           divisor = i;

  	   return divisor; 
  	}
    static int min (int x,int y,int z) {return Math.min(Math.min(x, y), z);}
    static long min (long x,long y,long z) {return Math.min(Math.min(x, y), z);}
    static int max (int x,int y,int z) {return Math.max(Math.max(x, y), z);}
    static long max (long x,long y,long z) {return Math.max(Math.max(x, y), z);}
	static class pair implements Comparable<pair>{
		String  name; int x,y,z ;
		
		
		public pair (int x,int y,int z) {
			this.x=x; this.y=y; this.z=z;
		}
		public int compareTo(pair o) {
			return o.z-z;
		}
		public String toString() {
			return x+" "+y+" "+z;
		}
	}

	static 	PrintWriter pw=new PrintWriter(System.out);
	
	static class InputReader  {
		 
		private InputStream in;
		private byte[] buffer = new byte[1024];
		private int curbuf;
		private int lenbuf;
 
		public InputReader(InputStream in) {
			this.in = in;
			this.curbuf = this.lenbuf = 0;
		}
 
		public boolean hasNextByte() {
			if (curbuf >= lenbuf) {
				curbuf = 0;
				try {
					lenbuf = in.read(buffer);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (lenbuf <= 0)
					return false;
			}
			return true;
		}
 
		private int readByte() {
			if (hasNextByte())
				return buffer[curbuf++];
			else
				return -1;
		}
 
		private boolean isSpaceChar(int c) {
			return !(c >= 33 && c <= 126);
		}
 
		private void skip() {
			while (hasNextByte() && isSpaceChar(buffer[curbuf]))
				curbuf++;
		}
 
		public boolean hasNext() {
			skip();
			return hasNextByte();
		}
 
		public String next() {
			if (!hasNext())
				throw new NoSuchElementException();
			StringBuilder sb = new StringBuilder();
			int b = readByte();
			while (!isSpaceChar(b)) {
				sb.appendCodePoint(b);
				b = readByte();
			}
			return sb.toString();
		}
 
		public int nextInt() {
			if (!hasNext())
				throw new NoSuchElementException();
			int c = readByte();
			while (isSpaceChar(c))
				c = readByte();
			boolean minus = false;
			if (c == '-') {
				minus = true;
				c = readByte();
			}
			int res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res = res * 10 + c - '0';
				c = readByte();
			} while (!isSpaceChar(c));
			return (minus) ? -res : res;
		}
 
		public long nextLong() {
			if (!hasNext())
				throw new NoSuchElementException();
			int c = readByte();
			while (isSpaceChar(c))
				c = readByte();
			boolean minus = false;
			if (c == '-') {
				minus = true;
				c = readByte();
			}
			long res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res = res * 10 + c - '0';
				c = readByte();
			} while (!isSpaceChar(c));
			return (minus) ? -res : res;
		}
 
		public double nextDouble() {
			return Double.parseDouble(next());
		}
 
		public int[] nextIntArray(int n) {
			int[] a = new int[n];
			for (int i = 0; i < n; i++)
				a[i] = nextInt();
			return a;
		}
 
		public long[] nextLongArray(int n) {
			long[] a = new long[n];
			for (int i = 0; i < n; i++)
				a[i] = nextLong();
			return a;
		}
 
	}

	}