Problem: Natasha is going to fly on a rocket to Mars and return to Earth. Also, on the way to Mars, she will land on n - 2 intermediate planets. Formally: we number all the planets from 1 to n. 1 is Earth, n is Mars. Natasha will make exactly n flights: 1 → 2 → … n → 1.

Flight from x to y consists of two phases: take-off from planet x and landing to planet y. This way, the overall itinerary of the trip will be: the 1-st planet → take-off from the 1-st planet → landing to the 2-nd planet → 2-nd planet → take-off from the 2-nd planet → … → landing to the n-th planet → the n-th planet → take-off from the n-th planet → landing to the 1-st planet → the 1-st planet.

The mass of the rocket together with all the useful cargo (but without fuel) is m tons. However, Natasha does not know how much fuel to load into the rocket. Unfortunately, fuel can only be loaded on Earth, so if the rocket runs out of fuel on some other planet, Natasha will not be able to return home. Fuel is needed to take-off from each planet and to land to each planet. It is known that 1 ton of fuel can lift off a_i tons of rocket from the i-th planet or to land b_i tons of rocket onto the i-th planet. 

For example, if the weight of rocket is 9 tons, weight of fuel is 3 tons and take-off coefficient is 8 (a_i = 8), then 1.5 tons of fuel will be burnt (since 1.5 ⋅ 8 = 9 + 3). The new weight of fuel after take-off will be 1.5 tons. 

Please note, that it is allowed to burn non-integral amount of fuel during take-off or landing, and the amount of initial fuel can be non-integral as well.

Help Natasha to calculate the minimum mass of fuel to load into the rocket. Note, that the rocket must spend fuel to carry both useful cargo and the fuel itself. However, it doesn't need to carry the fuel which has already been burnt. Assume, that the rocket takes off and lands instantly.

Input

The first line contains a single integer n (2 ≤ n ≤ 1000) — number of planets.

The second line contains the only integer m (1 ≤ m ≤ 1000) — weight of the payload.

The third line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 1000), where a_i is the number of tons, which can be lifted off by one ton of fuel.

The fourth line contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 1000), where b_i is the number of tons, which can be landed by one ton of fuel. 

It is guaranteed, that if Natasha can make a flight, then it takes no more than 10^9 tons of fuel.

Output

If Natasha can fly to Mars through (n - 2) planets and return to Earth, print the minimum mass of fuel (in tons) that Natasha should take. Otherwise, print a single number -1.

It is guaranteed, that if Natasha can make a flight, then it takes no more than 10^9 tons of fuel.

The answer will be considered correct if its absolute or relative error doesn't exceed 10^{-6}. Formally, let your answer be p, and the jury's answer be q. Your answer is considered correct if \frac{|p - q|}{max{(1, |q|)}} ≤ 10^{-6}.

Examples

Input

2
12
11 8
7 5


Output

10.0000000000


Input

3
1
1 4 1
2 5 3


Output

-1


Input

6
2
4 6 3 3 5 6
2 6 3 6 5 3


Output

85.4800000000

Note

Let's consider the first example.

Initially, the mass of a rocket with fuel is 22 tons.

  * At take-off from Earth one ton of fuel can lift off 11 tons of cargo, so to lift off 22 tons you need to burn 2 tons of fuel. Remaining weight of the rocket with fuel is 20 tons.
  * During landing on Mars, one ton of fuel can land 5 tons of cargo, so for landing 20 tons you will need to burn 4 tons of fuel. There will be 16 tons of the rocket with fuel remaining.
  * While taking off from Mars, one ton of fuel can raise 8 tons of cargo, so to lift off 16 tons you will need to burn 2 tons of fuel. There will be 14 tons of rocket with fuel after that.
  * During landing on Earth, one ton of fuel can land 7 tons of cargo, so for landing 14 tons you will need to burn 2 tons of fuel. Remaining weight is 12 tons, that is, a rocket without any fuel.



In the second case, the rocket will not be able even to take off from Earth.

Solution (in JAVA):

Solution:
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Writer;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.*;
import java.io.*;
import java.math.*;
public class Main
{
    public static long pow(long a, long b)
    {
        long result=1;
        while(b>0)
        {
            if (b % 2 != 0)
            {
                result=(result*a);
                b--;
            } 
            a=(a*a);
            b /= 2;
        }   
                return result;
            }
            public static BigInteger fact(long num)
            {
                BigInteger fact=new BigInteger("1");
                int i=0;
                for(i=1; i<=num; i++)
                {
                    BigInteger bg=BigInteger.valueOf(i);
                    fact=fact.multiply(bg);
                }
                return fact;
            }
            public static long gcd(long a, long b)
            {
                if (a == 0)
                    return b;
                return gcd(b%a, a);
            }
            
            public static long lcm(int a,int b)
            {
                return a * (b / gcd(a, b));
            }
            public static long sum(int h)
            {
                return (h*(h+1)/2);
            }
			static long modInverse(long a, long m)
		{
			long m0 = m;
        long y = 0, x = 1;
 
        if (m == 1)
            return 0;
 
        while (a > 1)
        {
            // q is quotient
            long q = a / m;
 
            long t = m;
 
            // m is remainder now, process
            // same as Euclid's algo
            m = a % m;
            a = t;
            t = y;
 
            // Update x and y
            y = x - q * y;
            x = t;
        }
 
        // Make x positive
        if (x < 0)
            x += m0;
 
        return x;
    }
            static void initializeDiffArray(int A[], int D[])
            {
                int n = A.length;
                D[0] = A[0];
                D[n] = 0;
                for (int i = 1; i < n; i++)
                    D[i] = A[i] - A[i - 1];
            }
            // Does range update
            static void update(int D[], int l, int r, int x)
            {
                D[l] += x;
                D[r + 1] -= x;
            }
            // Prints updated Array
        static int[] printArray(int A[], int D[])
        {
            for (int i = 0; i < A.length; i++) {
                if (i == 0)
                    A[i] = D[i];
 
            // Note that A[0] or D[0] decides
            // values of rest of the elements.
            else
                A[i] = D[i] + A[i - 1];
 
         //   System.out.print(A[i] + " ");
        }
			return A;
        //    System.out.println();
        //    return 0;
        }
			
		/*	public static void bfs()
			{
				jump[0]=0;
				Queue<Integer> q=new LinkedList<>();
				q.add(0);
				visited[0]=true;
				while(!q.isEmpty())
				{
					int x=q.poll();
					ArrayList<Integer> al=graph.get(ch[x]-'0');
					for(int i=0;i<al.size();i++)
					{
						int y=al.get(i);	
						if(visited[y]==false)
						{
							q.add(y);
							visited[y]=true;
							jump[y]=jump[x]+1;
						}
					}
					(graph.get(ch[x]-'0')).clear();
					if(x-1>=0 && visited[x-1]==false)
					{
						jump[x-1]=jump[x]+1;
						q.add(x-1);
						visited[x-1]=true;
					}
					if(x+1<=n-1 && visited[x+1]==false)
					{
						jump[x+1]=jump[x]+1;
						q.add(x+1);
						visited[x+1]=true;
					}
				}
				
			}
		*/
		static HashMap<Integer,Integer> hash;
			public static void main(String args[])throws IOException
            {
                InputReader in=new InputReader(System.in);
        		OutputWriter out=new OutputWriter(System.out);
        	//	long a=pow(26,1000000005);
        	//    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
				ArrayList<Integer> ar=new ArrayList<Integer>();
			//	ArrayList<Long> ar=new ArrayList<Long>();
			//	ArrayList<String> ar=new ArrayList<String>();
				TreeSet<Integer> ts=new TreeSet<>();
				int n=in.readInt();
				int m=in.readInt();
				int[] a=new int[n];
				int num=0;
				for(int i=0;i<n;i++)
				{
					a[i]=in.readInt();
					if(a[i]==1)
					{
						num=1;
					}
				}
				int[] b=new int[n];
				for(int i=0;i<n;i++)
				{
					b[i]=in.readInt();
					if(b[i]==1)
					{
						num=1;
					}
				}
				double low=0;
				double high=1e9+1;
				//System.out.println("Doube"+high);
				double mid=0,ans=-1;
				if(num!=1)
				{
					while(high-low>1e-6)
					{
						mid=low+(high-low)/2;
						if(isFeasible(m,mid,a,b,n)==true)
						{
							ans=mid;
							high=mid;
						}
						else
						{
							low=mid;
						}
					}
					if(ans==-1.0)
					{
						System.out.println("-1");
					}
					else
					{
						System.out.printf("%.7f\n",ans);
					}
				}
				else
				{
					System.out.println("-1");
				}
			}			
			public static boolean isFeasible(int m,double mid,int[] a,int[] b,int n)
			{
			//	System.out.println(mid);
				double m1=(double)m+mid;
				int flag=0;
				for(int i=0;i<n;i++)
				{
					double a1=(double)(m1/a[i]);
					m1=m1-a1;
					mid=mid-a1;
					if(mid<0)
					{
						flag=1;
						break;
					}
					double a2;
					if(i+1>n-1)
					{
						a2=(double)(m1/b[0]);
					}
					else
					{
						a2=(double)(m1/b[i+1]);
					}
					m1=m1-a2;
					mid=mid-a2;
				//	System.out.println("hlo "+ m1+" ");
					if(mid<0)
					{
						flag=1;
						break;
					}
				}
				if(flag==1)
				{
					return false;
				}
				else
				{
					return true;
				}
			}
        }
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
        class InputReader {
        	 
        	private InputStream stream;
        	private byte[] buf = new byte[1024];
        	private int curChar;
        	private int numChars;
        	private SpaceCharFilter filter;
         
        	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 int readInt() {
        		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 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);
        	}
        }
         
        class OutputWriter {
        	private final PrintWriter writer;
         
        	public OutputWriter(OutputStream outputStream) {
        		writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        	}
         
        	public OutputWriter(Writer writer) {
        		this.writer = new PrintWriter(writer);
        	}
         
        	public void print(Object...objects) {
        		for (int i = 0; i < objects.length; i++) {
        			if (i != 0)
        				writer.print(' ');
        			writer.print(objects[i]);
        		}
        	}
         
        	public void printLine(Object...objects) {
        		print(objects);
        		writer.println();
        	}
         
        	public void close() {
        		writer.close();
        	}
         
        	public void flush() {
        		writer.flush();
        	}
         
        	}
         
            class IOUtils {
         
        	public static int[] readIntArray(InputReader in, int size) {
        		int[] array = new int[size];
        		for (int i = 0; i < size; i++)
        			array[i] = in.readInt();
        		return array;
        	}
         
        	}