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>
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.StringTokenizer;


public class Main {

    
    private static boolean sameset(int a, int b, int[] uf) {
        
        return find(a,uf) == find(b,uf);
    }

    private static void union(int a, int b, int[] uf) {
        uf[find(a,uf)] = find(b,uf);
    }

    private static int find(int a, int[] uf) {
        if(a == uf[a])  return a;
        int root = find(uf[a],uf);
        uf[a] = root;
        return root;
    }

    private static void BFS(int i, int[][] G, int[][] path) {
       // System.out.println("source vertex "+i);
        int[] v = new int[G.length]; // current maximum dist in u---v path
        ArrayDeque<Integer> A = new ArrayDeque();
        A.add(i);
        while(A.isEmpty() == false){
            int u = A.pop();
            //System.out.println("for node "+u);
            for(int a=0;a<v.length;a++){
                if(G[u][a] > 0 && v[a]==0 && a!=i){//edge in MST, later make faster
                    //System.out.println(a+" is and edge from "+u);
                    if(G[u][a] > v[u]){
                        //System.out.println(" and it incrases the sub path max ");
                        v[a] = G[u][a];
                    }
                    else    v[a] = v[u];
                    path[i][a] = v[a];
                    path[a][i] = v[a];
                   // System.out.println("finally path from "+i+" to "+a+" is "+path[i][a]);
                    
                    A.add(a);
                }
            }
        }
    }

    private static int numd(int x) {
        Double xx = Double.parseDouble(String.valueOf(x));
        int y = (int) Math.log10(xx);
        return (y+1);
       
         
        
    }

    private static String primeFactor(int n, boolean[] x) {
        String ans = "";
        for(int i=2;i<x.length;i++){
            if(i*i > n) break;
            if(x[i]){
                //System.out.println("testing prome "+i);
                while(n!=1 && i*i <= n){
                    while(n%i==0){
                       // System.out.println(i+" can divide "+n);
                        if(ans.equals(""))  ans=String.valueOf(i);
                        else    ans+=" x "+i;
                        n/=i;
                    }
                    break;
                }
            }
        }
        if(n!=1){
           // System.out.println("Remainig "+n);
            if(ans.equals(""))  ans=String.valueOf(n);
            else    ans+=" x "+n;
        }
        return ans;
    }

    private static String solve(String s) {
        
        
        
        return null;
    }

    //counts the number of divisors using the fundamental theorem of arithmetic
    private static int getDivisorCount(int n) {
        
        int count = 1;
        
        int tmp = n;
        
        for(int i=2;i*i<=n;i=(i==2?3:i+2)){
            
            //System.out.println(i+" is odd");
            
            int pow = 0;
            
            while(n%i==0){
                pow+=1;
                n/=i;
            }
            
            if(pow != 0){
                ///System.out.println(i+" must be a prime");
                count*=(pow+1);
            }
        }
        
        if(n!=1){
            //System.out.println(n+" is the last prime factor");
            count*=2;
        }
        
        //System.out.println("number of divisors of "+tmp+" is "+count);
        return count;
    }

    private static long nchoosek(int n, int k) {
        
        long prod = 1;
        int j = 1;
        
        int st = Math.max(n-k, k)+1;
        int ed = Math.min(n-k, k);
        
        for(int i=st;i<=n;i++){
            for(;j<=ed;j++){
                if(prod%j==0)   prod/=j;
                else break;
            }
            prod*=i;
        }
        
        for(;j<=ed;j++){
            prod/=j;
        }
        
        return prod;
    }
    
    //related to extgcd problems
    private static boolean check() {
        //System.out.println(a+" "+b+" "+c1+" "+c2);
        if(n%ibgcd(a,b)!=0) {
           // System.out.println("not possible");
            return false;
        }
        
        extgcd(a,b);
        long gcd=0,m1=x,m2=y;
        gcd=d;
        m1*=(n/d);
        m2*=(n/d);
        a/=d;
        b/=d;
        
        double f1 = (m1/b);f1*=-1;
        double f2 = (m2/a);
        long le = (long) Math.ceil(f1);
        long re = (long) Math.floor(f2);
        if(le > re) return false;
        long cf=c1*b-c2*a;
        if(cf*le < cf*re){
        
            x = m1+b*le;
            y = m2-a*le;
        }else{
            x = m1+b*re;
            y = m2-a*re;
        }
        //System.out.println("upper and lower are "+le+" "+re);
        
        
        return true;
    }

    private static void extgcd(long a, long b) {
        
        if(b==0){
            x=1;y=0;d=a;return;
        }
        extgcd(b,a%b);
        long x1 = y;
        long y1 = x-(a/b)*y;
        x=x1;
        y=y1;
    }

    private static void floyd_cycle(int z, int I, int m, int x0) {
        
        int tor = func(z,I,m,x0);
        int har = func(z,I,m,tor); //one step ahead of tor
        //System.out.println("initial value for tor and har "+tor+" "+har);
        
        while(tor!=har){
            tor = func(z,I,m,tor);
            har = func(z,I,m,har);
            har = func(z,I,m,har);
            //System.out.println("tor and har "+tor+" "+har);
        }
        
        //at r-x%m now
        int x = 0;
        har = tor;
        tor = x0;
        
        while(har!=tor){
            
            tor = func(z,I,m,tor);
            har = func(z,I,m,har);
            x+=1;
            //System.out.println("findind x tor and har "+tor+" "+har);
        }
        
        //now at first reapting node
        int lam = 1;
        har = func(z,I,m,tor);
        
        while(har!=tor){
            har = func(z,I,m,har);
            lam+=1;
            //System.out.println("finding lam, tor and har "+tor+" "+har);
        }
        
       // return new Pair(z,lam);
    }

   private static int func(int z, int I, int m, int x0) {
        return ((z*x0)%m+I%m)%m;
    }

    private static void dfs(int a, int[][] d, int[] v,int[] p) {
        
        v[a] = 1;
        for(int i=0;i<v.length;i++){
            if(i!=a && d[i][a]!=0){
                if(v[i]==0){
                   // System.out.println("dfsing "+i);
                    p[i]=a;
                    dfs(i,d,v,p);
                }else if(p[a] != i && a<i){
                   // System.out.println(a+" and "+i+" causing cycle"+p[i]);
                    cycle=true;
                }
            }
        }
        
    }

    private static void dolve(int x, int[] a) {
        //find sors of x
        int cnt = 0;
        for(int i=2;i<=Math.sqrt(x);i=(i==2?3:i+2)){
            int pow = 0;
            while(x%i==0){
                x/=i;
                pow+=1;
            }
            if(pow!=0){
                for(int j=1;j<=pow;j++){
                    long f = (long) Math.pow(i, j);
                    
                    if(f<a.length){
                        a[Integer.parseInt(String.valueOf(f))]=1;
                        //System.out.println("ading "+Integer.parseInt(String.valueOf(f)));
                    }
                    
                }
            }
        }
        
        if(x!=1){
            //System.out.println("ading "+x);
            if(x<a.length)  a[x]=1;
        }
    }

   

    static class Node{
        
        int d=-1;
        long num;
        public Node(int a,long c){
            this.d = a;
            
            this.num = c;
            
        }
    }
    
    static class Edge{
        
        String d;
        int p;//ids of nodes
        int q;
        public Edge( String x1, int y1, int w){
            
            this.d = x1;
            this.p = y1;
            this.q = w;
        }
    }
    
    //simple sieve
    static boolean[] getPrimes(int n){
        
        boolean[] ret = new boolean[n+1];
        Arrays.fill(ret, true);
        
        ret[0] = ret[1] = false;
        
        for(int i=2;i*i <= n; i++){
            
            if(ret[i]){
                
                for(int j=i*i;j<=n;j+=i){
                    
                    ret[j]=false;
                }
            }
        }
        
        return ret;
    }
   
    static long ibgcd(long a, long b){
        
        while(b > 0){
            long r = a%b;
            a=b;
            b=r;
        }
        return a;
    }
    
    //for extgcd
    static long x,y,d; //output and gdc
    static long c1,c2,a,b,n; // inputs
    //static boolean[] p = getPrimes(5000001);
    
    static class Pair{
        int a;
        int b;
        int w;
        public Pair(int a, int b, int w){
            this.a=a;
            this.b=b;
            this.w=w;
        }
    }
    
    static boolean cycle = false;
    public static void main(String[] args) throws IOException {
        
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new PrintWriter(System.out));
      
        String[] _x = br.readLine().split(" ");
        //int n = Integer.parseInt(br.readLine());
        //int[] a = new int[n];
        //int[] b = new int[n];
        
        int a = Integer.parseInt(_x[0]);
        int b = Integer.parseInt(_x[1]);
        
        double aa = Double.parseDouble(String.valueOf(a));
        double bb = Double.parseDouble(String.valueOf(b));
        
        //goes past x-value 0
        if(a < b)   System.out.println(-1);
        else{
            
           int num = a+b;
           int den1 = (a+b)/(2*b);
           int den2 = 2*den1;
           
           //System.out.println(num+" "+den1+" "+den2);
           double ans = Double.parseDouble(String.valueOf(num))/Double.parseDouble(String.valueOf(den2));
            
            System.out.println(String.format( "%.12f", ans ));
            
            
            
        }
       
        bw.close();
    } 

} 