Problem: While sailing on a boat, Inessa noticed a beautiful water lily flower above the lake's surface. She came closer and it turned out that the lily was exactly H centimeters above the water surface. Inessa grabbed the flower and sailed the distance of L centimeters. Exactly at this point the flower touched the water surface.

<image>

Suppose that the lily grows at some point A on the lake bottom, and its stem is always a straight segment with one endpoint at point A. Also suppose that initially the flower was exactly above the point A, i.e. its stem was vertical. Can you determine the depth of the lake at point A?

Input

The only line contains two integers H and L (1 ≤ H < L ≤ 10^{6}).

Output

Print a single number — the depth of the lake at point A. The absolute or relative error should not exceed 10^{-6}.

Formally, let your answer be A, and the jury's answer be B. Your answer is accepted if and only if \frac{|A - B|}{max{(1, |B|)}} ≤ 10^{-6}.

Examples

Input


1 2


Output


1.5000000000000


Input


3 5


Output


2.6666666666667

Solution (in JAVA):

Solution:
import java.io.*;
import java.util.*;

public class Main {
    private static final int MAX = Integer.MAX_VALUE;
    private static final int MIN = Integer.MIN_VALUE;

    public static void main(String[] args) throws IOException {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        InputReader.OutputWriter out = new InputReader.OutputWriter(outputStream);
        Scanner scanner = new Scanner(System.in);


        double h = in.nextDouble();
        double l = in.nextDouble();
        double a = (l*l-h*h)/(2*h);
        out.println(a);






        out.flush();
    }
    private int xx;
    private int yy;
    public String alphabetBoardPath(String target) {
        StringBuilder sb = new StringBuilder();
        for(char c : target.toCharArray()) {
            runBFS(xx,yy,c,sb);
        }

        return sb.toString();
    }
    static void runBFS(int xx,int yy,char c,StringBuilder sb) {
        LinkedList<Point> q = new LinkedList<>();
        LinkedList<StringBuilder> qs = new LinkedList<>();
        q.add(new Point(xx,yy));
        while(!q.isEmpty()) {
            int size = q.size();
            while(size-->0) {
                Point current = q.pollFirst();
                StringBuilder s = qs.pollFirst();
                int x = current.getX();
                int y = current.getY();
                char ch  = getLetter(current);
                if(ch == c) {
                    xx = x;
                    yy = y;
                    sb.append(s+"!");
                    return;
                }

                Point down = new Point(x+1,y);
                Point up = new Point(x-1,y);
                Point left = new Point(x,y - 1);
                Point right = new Point(x,y + 1);
                if(canGo(down)) {
                    q.add(down);
                    s.append("D");
                }
                if(canGo(up)) {
                    q.add(up);
                    s.append("U");
                }
                if(canGo(left)) {
                    q.add(left);
                    s.append("L");
                }
                if(canGo(right)) {
                    q.add(right);
                    s.append("R");
                }
            }
        }
    }
    static char getLetter(Point p) {
        int x = p.getX();
        int y = p.getY();
        int value = x*5 + y;
        return (char)('a' + value);
    }
    static boolean canGo(Point p) {
        int x = p.getX();
        int y = p.getY();
        if(x== 5 && y==0) return true;
        return x>=0 && y>=0 && x<5 && y<5;
    }
    public int findNumberOfLIS(int[] nums) {
        int n = nums.length;
        HashMap<Integer,Integer> map = new HashMap<>();
        int [] dp = new int[n];
        Arrays.fill(dp,1);
        int max_Index = 0;
        for(int i=0;i<nums.length;i++) {
            for(int j=0;j<i;j++) {
                if(nums[i] > nums[j]) {
                    dp[i] = Math.max(dp[i],dp[j] + 1);
                    if(dp[i] > dp[max_Index]) {
                        max_Index = i;
                    }
                }
            }
        }
        int ans = 1;
        for(int i=0;i<max_Index;i++) {
            map.put(dp[i],map.getOrDefault(dp[i],0) + 1);
        }
        for (Map.Entry<Integer,Integer> m : map.entrySet()) {
            ans*=m.getValue();
        }
        System.out.println(max_Index);
        System.out.println(Arrays.toString(dp));
        System.out.println(map);
        return map.isEmpty() ? 1 : ans;
    }
    private void modifyValue(int key, HashMap<Integer,Integer> map) {
        if(map.containsKey(key)) {
            int value = map.get(key);
            if(value == 1) {
                map.remove(key);
            }
            else {
                map.put(key,map.get(key) - 1);
            }
        }
    }
    public int[][] insert(int[][] intervals, int[] newInterval) {
        int newPosition = binary_search(intervals,newInterval);
        int[][] a = newIntervals(intervals,newInterval,newPosition);
        List<int[]> ans = new ArrayList<>();
        int[] current = a[0];
        for(int i=1;i<a.length;i++) {
            if(current[1] >= a[i][0]) {
                current[0] = Math.min(current[0],a[i][0]);
                current[1]  = Math.max(current[1],a[i][1]);
            }
            else {
                ans.add(current);
                current = a[i];
            }
        }
        ans.add(current);
        int[][] res = new int[ans.size()][2];
        for(int i=0;i<res.length;i++) {
            res[i] = ans.get(i);
        }
        return res;
    }
    private int[][] newIntervals(int[][] intervals,int[] newInterval, int position) {
        int[][] ans = new int[intervals.length + 1][2];
        for(int i=0;i<position;i++) {
            ans[i] = intervals[i];
        }
        ans[position] = newInterval;
        for(int i=position + 1;i<ans.length;i++) {
            ans[i] = intervals[i-1];
        }
        return ans;
    }
    private int binary_search(int[][] intervals, int [] newInterval) {
        int lo = 0;
        int hi = intervals.length - 1;
        while(lo<=hi) {
            int med = lo +(hi-lo)/2;
            if(newInterval[0] > intervals[med][0]) {
                lo = med + 1;
            }
            else {
                hi = med - 1;
            }
        }
        return lo;
    }


    static int numberOfSubsequences(String a, String b) {
        int [] dp = new int[b.length()+1];
        dp[0] = 1;
        for (int i = 0; i < a.length(); i++) {
            for (int j = b.length() - 1; j >=0;j--) {
                if(a.charAt(i) == b.charAt(j)) {
                    dp[j+1]+=dp[j];
                }
            }
        }
        return dp[dp.length - 1];
    }
    static long count(String a, String b)
    {
        int m = a.length();
        int n = b.length();

        // Create a table to store
        // results of sub-problems
        long lookup[][] = new long[m + 1][n + 1];

        // If first string is empty
        for (int i = 0; i <= n; ++i)
            lookup[0][i] = 0;

        // If second string is empty
        for (int i = 0; i <= m; ++i)
            lookup[i][0] = 1;

        // Fill lookup[][] in
        // bottom up manner
        for (int i = 1; i <= m; i++)
        {
            for (int j = 1; j <= n; j++)
            {
                // If last characters are
                // same, we have two options -
                // 1. consider last characters
                //    of both strings in solution
                // 2. ignore last character
                //    of first string
                if (a.charAt(i - 1) == b.charAt(j - 1))
                    lookup[i][j] = lookup[i - 1][j - 1] +
                            lookup[i - 1][j];

                else
                    // If last character are
                    // different, ignore last
                    // character of first string
                    lookup[i][j] = lookup[i - 1][j];
            }
        }

        return lookup[m][n];
    }
    static int num (int n) {
        return n-1;
    }

}
class Point {
    private int x;
    private int y;
    public int getX() {
        return x;
    }
    public int getY() {
        return y;
    }
    public Point(int x,int y) {
        this.x = x;
        this.y = y;
    }
}
class Number {
    int value;
    int index;
    public Number(int value,int index) {
        this.value = value;
        this.index = index;
    }
}

class Lift {

    int level;
    int time;

    public int getLevel() {
        return level;
    }

    public int getTime() {
        return time;
    }

    public Lift(int level, int time) {
        this.level = level;
        this.time = time;
    }
}

class InputReader extends BufferedReader {
    StringTokenizer tokenizer;

    public InputReader(InputStream inputStream) {
        super(new InputStreamReader(inputStream), 32768);
    }

    public InputReader(String filename) {
        super(new InputStreamReader(Thread.currentThread().getContextClassLoader().getResourceAsStream(filename)));
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(readLine());
            } catch (IOException e) {
                throw new RuntimeException();
            }
        }
        return tokenizer.nextToken();
    }

    public Integer nextInt(){
        return Integer.valueOf(next());
    }
    public Long nextLong() {
        return  Long.valueOf(next());
    }
    public Double nextDouble() {
        return Double.valueOf(next());
    }
    static class OutputWriter extends PrintWriter {
        public OutputWriter(OutputStream outputStream) {
            super(outputStream);
        }

        public OutputWriter(Writer writer) {
            super(writer);
        }

        public OutputWriter(String filename) throws FileNotFoundException {
            super(filename);
        }

        public void close() {
            super.close();
        }
    }
}