Problem: There is a polyline going through points (0, 0) – (x, x) – (2x, 0) – (3x, x) – (4x, 0) – ... - (2kx, 0) – (2kx + x, x) – .... 

We know that the polyline passes through the point (a, b). Find minimum positive value x such that it is true or determine that there is no such x.

Input

Only one line containing two positive integers a and b (1 ≤ a, b ≤ 109).

Output

Output the only line containing the answer. Your answer will be considered correct if its relative or absolute error doesn't exceed 10 - 9. If there is no such x then output  - 1 as the answer.

Examples

Input

3 1


Output

1.000000000000


Input

1 3


Output

-1


Input

4 1


Output

1.250000000000

Note

You can see following graphs for sample 1 and sample 3. 

<image> <image>

Solution (in JAVA):

Solution:
													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.HashMap;
	import java.util.HashSet;
	import java.util.InputMismatchException;
	import java.util.Iterator;
	import java.util.TreeSet;
									public class Solution1 implements Runnable
									{
										static final long MAX = 1000000007L;
										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 Solution1(),"Solution1",1<<26).start();
										}
										
										static long gcd(long a, long b)
									    {
									        // Everything divides 0 
									        if (a == 0 || b == 0)
									           return 0;
									     
									        // base case
									        if (a == b)
									            return a;
									     
									        // a is greater
									        if (a > b)
									            return gcd(a-b, b);
									        return gcd(a, b-a);
									    }
									    
									    // method to return LCM of two numbers
									    static long lcm(long a, long b)
									    {
									        return (a*b)/gcd(a, b);
									    }
									    class Node{
									    	long val;
									    	int ind;
									    	Node(long val,int ind){
									    		this.val = val;
									    		this.ind = ind;
									    	}
									    }
									    
									    TreeSet<Integer> ar[];
										public void run()
										{
											InputReader sc= new InputReader(System.in);
											PrintWriter w= new PrintWriter(System.out);
											int a = sc.nextInt();
											int b = sc.nextInt();
											if(a < b) {
												w.println(-1);
											}else {
												int c = b + a;
												int y = (c / (2 * b));
												double ans = c / (2.0*y);
												System.out.printf("%.12f",ans);
											}
											w.close();
											
										}
										class Nod{
											int x;
											int y;
											int z;
											int l;
											Nod(int x,int y,int z,int l){
												this.x = x;
												this.y = y;
												this.z = z;
												this.l = l;
											}
										}
										boolean isPossible(long n,long mid,long in) {
											long mi = mid;
											long y = (mi * (mi +1))/2;
											
											if(mid <= in) {
												if(y >= n) {
													return true;
												}
												return false;
											}else {
												long diff = mid - in;
												if(diff % 2 == 0) {
													long n1 = diff/2 + 1;
													long sum = (n1 * diff)/2;
													if(y - sum >= n) {
														return true;
													}
													return false;
												}else {
													long n1 = (diff - 1)/2 + 1;
													long sum = (n1 * (diff + 1))/2;
													if(y - sum >= n) {
														return true;
													}
													return false;
												}
											}
										}
										static class Pair implements Comparable<Pair>{
											int a ;
											int b;
											int c;
											Pair (int c,int a,int b){
												this.a = a;
												this.b = b;
												this.c = c;
											}
											public int compareTo(Pair p){
												return Integer.compare(p.c,this.c);
											}
										}
						}