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.*;
import java.util.StringTokenizer;

public class C {

    private static class Solution implements Runnable {

        private static final long modulo = 1000000007;


        private void solve() {

            int a = in.nextInt();
            int b = in.nextInt();


            if (a < b) {
                out.println("-1");
            } else {
                double ans = (a + (double)b) / (2 * ((a + b) / (2 * b)));
                out.printf("%.10f", ans);
            }

        }

        private int gcd(int a, int b) {
            if (b == 0)
                return a;
            else
                return gcd(b, a % b);
        }

        private long inverse(long a) {
            long result = 1;
            int n = (int) modulo - 2;
            while (n != 0) {
                if ((n & 1) == 1)
                    result = (result * a) % modulo;
                a = (a * a) % modulo;
                n >>= 1;
            }
            return result;
        }

        private long pow(long a, long n) {
            if (n == 0) return 1;
            if (n % 2 == 0) {
                long ans = pow(a, n / 2);
                return ans * ans;
            } else {
                return a * pow(a, n - 1);
            }
        }

        private void closeStreams() {
            in.close();
            out.close();
        }

        @Override
        public void run() {
            solve();
            closeStreams();
        }

        private final FastScanner in = new FastScanner();
        private final PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
    }


    public static void main(String[] args) {
        Thread thread = new Thread(null, new Solution(), "solution", 1 << 27);
        thread.setPriority(Thread.MAX_PRIORITY);
        thread.start();
    }


    public static class FastScanner {

        private BufferedReader br;
        private StringTokenizer st;

        public FastScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

        void close() {
            try {
                br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}