Shrek and the Donkey (as you can guess, they also live in the far away kingdom) decided to play a card game called YAGame. The rules are very simple: initially Shrek holds m cards and the Donkey holds n cards (the players do not see each other's cards), and one more card lies on the table face down so that both players cannot see it as well. Thus, at the beginning of the game there are overall m + n + 1 cards. Besides, the players know which cards the pack of cards consists of and their own cards (but they do not know which card lies on the table and which ones the other player has). The players move in turn and Shrek starts. During a move a player can: Try to guess which card is lying on the table. If he guesses correctly, the game ends and he wins. If his guess is wrong, the game also ends but this time the other player wins. Name any card from the pack. If the other player has such card, he must show it and put it aside (so that this card is no longer used in the game). If the other player doesn't have such card, he says about that. Recently Donkey started taking some yellow pills and winning over Shrek. Now Shrek wants to evaluate his chances to win if he too starts taking the pills.Help Shrek assuming the pills are good in quality and that both players using them start playing in the optimal manner.

The first line contains space-separated integers m and n (0 ≤ m, n ≤ 1000).

Print space-separated probabilities that Shrek wins and Donkey wins correspondingly; the absolute error should not exceed 10 - 9.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class Crocodile implements Runnable {
    private void solve() throws IOException {
        int m = nextInt();
        int n = nextInt();
        int mx = Math.max(n, m);
        double[][] ans = new double[mx + 1][mx + 1];
        for (int sum = 0; sum <= mx + mx; ++sum) {
            for (int a = 0; a <= mx; ++a) {
                int b = sum - a;
                if (b >= 0 && b <= mx) {
                    ans[a][b] = doit(a, b, ans);
                }
            }
        }
        writer.println(ans[m][n] + " " + (1.0 - ans[m][n]));
    }

    private double doit(int m, int n, double[][] ans) {
        double res = 1.0 / (n + 1);
        if (m == 0 || n == 0) return res;
        double borderP = 1 / (ans[n][m - 1] * (n + 1) + 1);
        res = Math.max(res, eval(m, n, ans, 0.0));
        res = Math.max(res, eval(m, n, ans, borderP));
        res = Math.max(res, eval(m, n, ans, 1.0));
        return res;
    }

    private double eval(int m, int n, double[][] ans, double p) {
        return (1 - p) * n / (n + 1.0) * (1 - ans[n - 1][m]) + (p + (1 - p) / (n + 1.0) - Math.max((1 - p) / (n + 1), p * ans[n][m - 1]));
    }

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

    BufferedReader reader;
    StringTokenizer tokenizer;
    PrintWriter writer;

    public void run() {
        try {
            reader = new BufferedReader(new InputStreamReader(System.in));
            tokenizer = null;
            writer = new PrintWriter(System.out);
            solve();
            reader.close();
            writer.close();
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

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

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

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

    String nextToken() throws IOException {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            tokenizer = new StringTokenizer(reader.readLine());
        }
        return tokenizer.nextToken();
    }
}