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.awt.List;
    		import java.io.*;
    		import java.util.*;

    		
    		
    		/*
    		 * 
    		 * daiict
    		 *
    		 * 
    		 * 
    		 */
    		
    		
    		public class prac {
    			FastScanner in;
    			PrintWriter out;
    		
    			static ArrayList[] adj;
    			
    			static int n;
    			static int m;
    			
    			static int[] dp1;
    			static int[] dp2;
    			static int color[];
    			static int visited[];
    			static long[] arr;
    			static long[] brr;
    			static long ans;
    			static int array[];
    			static int pref[];
    			static int tree[];
    			static int maxval = 32;
    		
    			static int sum = 0;
    		//for dfs do not delete
    			static int dir[][] ={{1,0},{0,1},{0,-1},{-1,0},{1,1},{1,-1},{-1,1},{-1,-1}};
    			
    		
    			static long[] seg;
    			static long count = 1;
    			static long mod = (long)1e9 + 7;
    	
    			static int parent[];
    			static int size[];
    			
    			static class Pair implements Comparable<Pair>
    		    {
    				long x;int y;
    				
    		        Pair(long l, int m) {
    		          
    		        	this.x = l;
    		            this.y = m;
    		          
    		        }
    		        
    		        public int compareTo(Pair p) {
    		            if (this.x == p.x) {
    		                return (int)(this.y-p.y);
    		            }
    		            return (int)(this.x - p.x);
    		        }
    		        
    		        public String toString(){
    		        	return x + " " + y;
    		        }
    		        
    		        public boolean equals(Object o){
    		        	if(o instanceof Pair){
    		        		Pair a = (Pair)o;
    		        		
    		        		return this.x == a.x;
    		        	}
    		        	
    		        	return false;
    		        }
    		        
    		        public int hashCode(){
    		        	return new Long(x).hashCode()*31 + new Long(y).hashCode();
    		        }
    		    
    		    }
    		    
    			
    			public static int gcd(int a, int b) {
    				if (b == 0) return a;
    				return gcd(b, a%b);
    			}
    	
    			void build(int n) {  // build the tree
    				  for (int i = n - 1; i > 0; --i) seg[i] = Math.max(seg[i<<1],seg[i<<1|1]);
    				}
     
    			public static void modify(int p, int i,long val,int n) {  // set value at position p
    					if(i == 1){
    						long temp = val;
    						val = seg[p+n] - arr[p] + val;
    						arr[p] = temp;
    					}else{
    						val = Math.min(val, p) + arr[p];
    						brr[p] = val;
    					}
    					
    				  for (seg[p += n] = val; p > 1; p >>= 1) seg[p>>1] = Math.max(seg[p],seg[p^1]);
    				}
     
    				long query(int l, int r,int n) {  // max on interval [l, r)
    				  long res = Integer.MIN_VALUE;
    				  for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
    				    if ((l&1) == 1) res = (int)Math.max(res,seg[l++]);
    				    if ((r&1) == 1) res = (int)Math.max(res,seg[--r]);
    				  }
    				  return res;
    				}
    				
    			public static void update(int x,int val){
    				while(x<=maxval){
    					tree[x] += val;
    					x = (x&-x);
    				}
    			}
    			
    			public static int read(int idx){
    				int sum = 0;
    				
    				while(idx>= 0){
    					sum += tree[idx];
    					idx -= (idx&(-idx));
    				}
    				
    				return sum;
    			}
    			
    			public static int find(int i){
    				if(parent[i] != i){
    					return find(parent[i]);
    				}
    				
    				return i;
    			}
    			
    			public static void union(int a,int b){
    				int x = find(a);
    				int y = find(b);
    				
    				if(x!=y){
    					if(size[x] > size[y]){
    						size[x] += size[y];
    						parent[y] = x;
    					}else{
    						size[y] += size[x];
    						parent[x] = y;
    					}
    				}
    			}
    			
    		    void solve() throws NumberFormatException, IOException {
    		 
    		    	//Scanner in = new Scanner(System.in);
    		    	
    		    	int a = in.nextInt();
    		    	int b = in.nextInt();
    		    	
    		    	if(b>a){
    		    		out.print(-1);
    		    		return;
    		    	}
    		    	
    		    	double aa = a;
    		    	double bb = b;
    		    	
    		    	double ans = (aa+bb)/(2*((a+b)/(2*b)));
    		    	out.println(ans);
    		    	
	    
    		    }
    		    
    		    public static int fact(int a,int b){
    		    	if(b == 0){
    		    		return 1;
    		    	}
    		    	
    		    	return a*fact(a-1,b-1)/b;
    		    }
    		    
    		    public static void ddfss(int i,int p){
    		    	
    		    	array[i] = color[p];
    		    	
    		    	for(int j = 0;j<adj[i].size();j++){
    		    		if((int)adj[i].get(j) != p){
    		    			
    		    			ddfss((int)adj[i].get(j),i);
    		    		}
    		    	}
    		    }
    		    
    		    public static void ddfs(int i,int p){

    		    	//System.out.println(i + " " +p);
    		    	
    		    	if(color[i] != array[i]){
    		    		sum++;
    		    	//	System.out.println(i + "dd");
    		    		ddfss(i,p);
    		    		
    		    	}
	
    		    	for(int j = 0;j<adj[i].size();j++){
    		    		if((int)adj[i].get(j) != p){
    		    			ddfs((int)adj[i].get(j),i);
    		    		}
    		    	}
    		    	
    		    }
    		    
    		    public static long invcount(int arr[]){
    		    	if(arr.length<2){
    		    		return 0;
    		    	}
    		    	
    		    	int mid = (arr.length + 1)/2;
    		    	
    		    	int left[] = Arrays.copyOfRange(arr, 0,mid);
    		    	int right[] = Arrays.copyOfRange(arr, mid, arr.length);
    		    	
    		    	return invcount(left)+invcount(right)+merge(arr,left,right);
    		    	
    		    }
    		    
    		    public static long merge(int arr[],int left[],int right[]){
    		    	long count = 0;
    		    	
    		    	int i = 0;
    		    	int j = 0;
    		    	
    		    	while(i<left.length || j < right.length){
    		    		
    		    		if(i == left.length){
    		    			arr[i+j] = right[j];
    		    			j++;
    		    		}else if(j == right.length){
    		    			arr[j+i] = left[i];
    		    			i++;
    		    		}else{
    		    			if(left[i] <= right[j]){
    		    				arr[i+j] = left[i];
    		    				i++;
    		    			}else{
    		    				arr[i+j] = right[j];
    		    				j++;
    		    				count += left.length-i;
    		    			}
    		    		}
    		    		
    		    	}
    		    	
    		    	return count;
    		    }
    		    
    		  
    		    
    		    /**
    		     * 
    		     * @param div
    		     * @param left
    		     * @param right
    		     * @param value
    		     * @return the smallest index i which a[i] >= value in range [left, right) if exists, otherwise return -1
    		     */
    		    int ff(int[] div, int left, int right, int value) {
    		        int low = left;
    		        int high = right;
    		        
    		        if(value > div[right-1]){
    		        	return left;
    		        }
    		        
    		        while (low != high) {
    		            int mid = (low + high) / 2;
    		            if (div[mid] < value) {
    		                low = mid + 1;
    		            } else {
    		                high = mid;
    		            }
    		        }
    		        if (low == right) {
    		            return low;
    		        }
    		        return low;
    		    } 
    		   
    		    /**
    		     * 
    		     * @param div
    		     * @param left
    		     * @param right
    		     * @param value
    		     * @return greatest index i which a[i] <= value in range [left, right) if exists, otherwise return a number out of [left, right)
    		     */
    		    int ffff(int[] div, int left, int right, int value) {
    		        
    		    	if(value < div[left]){
    		    		return right-1;
    		    	}
    		    	
    		    	while (left != right) {
    		            int mid = (left + right) >> 1;
    		            if (div[mid] <= value) {
    		                left = mid + 1;
    		            } else {
    		                right = mid;
    		            }
    		        }
    		        if (left < 0) {
    		            left *= -1;
    		        }
    		        return --left;
    		    }
	    
    		   
    		  
    		
    		    public static String reverse(String s){
    		    	
    		    	String ans = "";
    		    	
    		    	for(int i = s.length()-1;i>=0;i--){
    		    		ans += s.charAt(i);
    		    	}
    		    	
    		    	return ans;
    		    	
    		    }
    			
    			
    		    
    		 
    		    public static long sum(long x){
    		    	return x<10?x:x%10 + sum(x/10);
    		    }
    			
    			public static long gcd(long x, long y) {
    				if (x == 0)
    					return y;
    				else
    					return gcd( y % x,x);
    			}
    			static long inv(long x , long mod)
    			{
    				long r,y;
    				for(r=1,y=mod-2;y!=0;x=x*x%mod,y>>=1)
    				{
    					if((y&1)==1)
    						r=r*x%mod;
    				
    				}
    				return r;
    			}
    			
    			public static long pow(long x,long y,long n){
    				if(y==0)
    					return 1%n;
    				if(y%2==0){
    					long z=pow(x,y/2,n);
    					return (z*z)%n;
    				}
    				return ((x%n)*pow(x,y-1,n))%n;
    			}
    			
    			
    			
    			
    			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;
    			}
    			
    		
    			void run() throws NumberFormatException, IOException {
    				in = new FastScanner();
    				out = new PrintWriter(System.out);
    		
    				solve();
    		
    				out.close();
    			}
    		
    			class FastScanner {
    				BufferedReader br;
    				StringTokenizer st;
    		
    				public FastScanner() {
    					br = new BufferedReader(new InputStreamReader(System.in));
    				}
    		
    				String next() {
    					while (st == null || !st.hasMoreTokens()) {
    						try {
    							st = new StringTokenizer(in.br.readLine());
    						} catch (IOException e) {
    							// TODO Auto-generated catch block
    							e.printStackTrace();
    						}
    					}
    					return st.nextToken();
    				}
    		
    				int nextInt() {
    					return Integer.parseInt(next());
    				}
    		
    				long nextLong() {
    					return Long.parseLong(next());
    				}
    		
    				double nextDouble() {
    					return Double.parseDouble(next());
    				}
    			}
    			
    			
    			
    			
    		 
    		
    			public static void main(String[] args) throws NumberFormatException, IOException {
    				new prac().run();
    			}
    		}
    		class Node{
    			String s;
    			int b;
    			
    		}
    		
    		class MyComp implements Comparator<String>{
    		    
    			int c = 0;
    			
    			MyComp(int d){
    				c = d;
    			}
    			
    			@Override
    			public int compare(String a,String b) {
    				
    				// < == -1
    				
    				String arr[] = a.split(" ");
    				String brr[] = b.split(" ");
    				
    				return arr[c].compareTo(brr[c]);
    				
    				
    			}

    			
    		}
    		
    		class MyComp2 implements Comparator<Node>{
    		    
    		
    			
    			@Override
    			public int compare(Node a,Node b) {
    				
    				// < == -1

    				
    				if(a.b > b.b){
    					return -1;
    				}else{
    					return 1;
    				}
    				
    				
    			}

    			
    		}