Tarly has two different type of items, food boxes and wine barrels. There are f food boxes and w wine barrels. Tarly stores them in various stacks and each stack can consist of either food boxes or wine barrels but not both. The stacks are placed in a line such that no two stacks of food boxes are together and no two stacks of wine barrels are together.

The height of a stack is defined as the number of items in the stack. Two stacks are considered different if either their heights are different or one of them contains food and other contains wine.

Jon Snow doesn't like an arrangement if any stack of wine barrels has height less than or equal to h. What is the probability that Jon Snow will like the arrangement if all arrangement are equiprobably?

Two arrangement of stacks are considered different if exists such i, that i-th stack of one arrangement is different from the i-th stack of the other arrangement.

Input

The first line of input contains three integers f, w, h (0 ≤ f, w, h ≤ 105) — number of food boxes, number of wine barrels and h is as described above. It is guaranteed that he has at least one food box or at least one wine barrel.

Output

Output the probability that Jon Snow will like the arrangement. The probability is of the form <image>, then you need to output a single integer p·q - 1 mod (109 + 7).

Examples

Input

1 1 1


Output

0


Input

1 2 1


Output

666666672

Note

In the first example f = 1, w = 1 and h = 1, there are only two possible arrangement of stacks and Jon Snow doesn't like any of them.

In the second example f = 1, w = 2 and h = 1, there are three arrangements. Jon Snow likes the (1) and (3) arrangement. So the probabilty is <image>.

<image>
import java.io.*;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.*;

public class Template implements Runnable {

    BufferedReader in;
    PrintWriter out;
    StringTokenizer tok = new StringTokenizer("");

    void init() throws FileNotFoundException {
        try {
            in = new BufferedReader(new FileReader("input.txt"));
            out = new PrintWriter("output.txt");
        } catch (Exception e) {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
        }
    }

    String readString() throws IOException {
        while (!tok.hasMoreTokens()) {
            try {
                tok = new StringTokenizer(in.readLine());
            } catch (Exception e) {
                return null;
            }
        }
        return tok.nextToken();
    }

    int readInt() throws IOException {
        return Integer.parseInt(readString());
    }

    int[] readIntArray(int size) throws IOException {
        int[] res = new int[size];
        for (int i = 0; i < size; i++) {
            res[i] = readInt();
        }
        return res;
    }

    long readLong() throws IOException {
        return Long.parseLong(readString());
    }

    double readDouble() throws IOException {
        return Double.parseDouble(readString());
    }

    <T> List<T>[] createGraphList(int size) {
        List<T>[] list = new List[size];
        for (int i = 0; i < size; i++) {
            list[i] = new ArrayList<>();
        }
        return list;
    }

    public static void main(String[] args) {
        new Template().run();
        // new Thread(null, new Template(), "", 1l * 200 * 1024 * 1024).start();
    }

    long timeBegin, timeEnd;

    void time() {
        timeEnd = System.currentTimeMillis();
        System.err.println("Time = " + (timeEnd - timeBegin));
    }

    long memoryTotal, memoryFree;

    void memory() {
        memoryFree = Runtime.getRuntime().freeMemory();
        System.err.println("Memory = " + ((memoryTotal - memoryFree) >> 10)
                + " KB");
    }

    public void run() {
        try {
            timeBegin = System.currentTimeMillis();
            memoryTotal = Runtime.getRuntime().freeMemory();
            init();
            solve();
            out.close();
            if (System.getProperty("ONLINE_JUDGE") == null) {
                time();
                memory();
            }
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(-1);
        }
    }

    long[] fact;
    long[] revfact;
    int mod = (int) 1e9 + 7;

    long binpow(long x, int p, int mod) {
        if (p == 0) {
            return 1 % mod;
        }
        if (p % 2 == 0) {
            long half = binpow(x, p / 2, mod);
            return half * half % mod;
        } else {
            return x * binpow(x, p - 1, mod) % mod;
        }
    }

    long C(int n, int k) {
        if (k > n) return 0;
        long answer = fact[n];
        answer = answer * revfact[n - k] % mod;
        answer = answer * revfact[k] % mod;
        return answer;
    }

    long ways(int columns, int count, int minHeight) {
        if (columns == 0) {
            if (count == 0) return 1;
            return 0;
        }
        if (count / minHeight < columns) return 0;
        if (columns == 1) return 1;
        int ost = count - columns * minHeight;
        //return binpow(ost + 1, columns - 1, mod);
        int n = ost;
        int m = columns;
        return C(n + m - 1, m - 1);

       // return C(ost + 1, columns - 1);

//        return binpow(columns, ost, mod);
    }

    void solve() throws IOException {
        int MAX = 2 * 100000 + 100;
        fact = new long[MAX];
        revfact = new long[MAX];
        fact[0] = revfact[0] = 1;
        for (int i = 1; i < MAX; i++) {
            fact[i] = fact[i - 1] * i % mod;
            revfact[i] = binpow(fact[i], mod - 2, mod);
        }
        int f = readInt();
        int w = readInt();
        int h = readInt();
        if (w == 0) {
            out.println(1);
            return;
        }

        long correct = 0;
        long all = 0;

        for (int wineColumns = 1; wineColumns <= w; wineColumns++) {
            long foodCount = (ways(wineColumns - 1, f, 1) + ways(wineColumns + 1, f, 1) + ways(wineColumns, f, 1) * 2) % mod;
            all += ways(wineColumns, w, 1) * foodCount % mod;
            all %= mod;
            correct += ways(wineColumns, w, h + 1) * foodCount % mod;
            correct %= mod;
        }
        long answer = correct * binpow(all, mod - 2, mod) % mod;
        //long etalon = new NaiveSolver().solve(f, w, h);
        //if (answer != etalon) throw new RuntimeException("answer not equal etalon");
        out.println(answer);
    }

    class NaiveSolver {

        long solve(int f, int w, int h) {
            brut(f, w, h, true, true, "");
            brut(f, w, h, true, false, "");
            return correct * binpow(all, mod - 2, mod) % mod;
        }

        long correct;
        long all;

        void brut(int f, int w, int h, boolean nowAllOk, boolean nowWine, String represent) {
            if (f == 0 && w == 0) {
                all++;
                if (nowAllOk) correct++;
                System.err.println(represent);
                return;
            }
            if (nowWine) {
                if (w == 0) return;
            } else {
                if (h == 0) return;
            }
            if (nowWine) {
                for (int i = 1; i <= w; i++) {
                    brut(f, w - i, h, nowAllOk & (i > h), !nowWine, represent + str('w', i));
                }
            } else {
                for (int i = 1; i <= f; i++) {
                    brut(f - i, w, h, nowAllOk, !nowWine, represent + str('f', i));
                }
            }
        }
    }

    String str(char x, int cnt) {
        String res = "";
        while (cnt-- > 0) {
            res += x;
        }
        return res;
    }


}