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

public class A implements Runnable {
    private static BufferedReader in;
    private static PrintWriter out;
    private static StringTokenizer st;
    private static Random rnd;

    private void solve() throws IOException {
        boolean found = false;
        double result = Long.MAX_VALUE;

        long a = nextLong(), b = nextLong();

        if (a == b) {
            out.println(a);
            return;
        }

        if (a >= b) {
            long l = 0, r = Integer.MAX_VALUE;

            while (r - l > 1) {
                long x = (l + r) / 2;
                if ((a - b) >= b * 2 * x) {
                    l = x;
                } else {
                    r = x;
                }
            }

            if (l > 0) {
                result = (double) (a - b) / (2 * l);
                found = true;
            }
        }

        {
            long l = -1, r = Integer.MAX_VALUE;

            while (r - l > 1) {
                long x = (l + r) / 2;
                if ((a + b) >= b * 2 * (x + 1)) {
                    l = x;
                } else {
                    r = x;
                }
            }

            if (l >= 0) {
                result = Math.min(result, (double) (a + b) / (2 * (l + 1)));
                found = true;
            }
        }

        out.println(found ? result : "-1");
    }

    public static void main(String[] args) {
        new A().run();
    }

    public void run() {
        try {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
            rnd = new Random();

            solve();

            out.close();
        } catch (IOException e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

    private String nextToken() throws IOException {
        while (st == null || !st.hasMoreTokens()) {
            String line = in.readLine();

            if (line == null)
                return null;

            st = new StringTokenizer(line);
        }

        return st.nextToken();
    }

    private int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }

    private long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }

    private double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }
}