You are given three integers k, pa and pb.You will construct a sequence with the following algorithm: Initially, start with the empty sequence. Each second, you do the following. With probability pa / (pa + pb), add 'a' to the end of the sequence. Otherwise (with probability pb / (pa + pb)), add 'b' to the end of the sequence.You stop once there are at least k subsequences that form 'ab'. Determine the expected number of times 'ab' is a subsequence in the resulting sequence. It can be shown that this can be represented by P / Q, where P and Q are coprime integers, and . Print the value of .

The first line will contain three integers integer k, pa, pb (1 ≤ k ≤ 1 000, 1 ≤ pa, pb ≤ 1 000 000).

Print a single integer, the answer to the problem.

NoteThe first sample, we will keep appending to our sequence until we get the subsequence 'ab' at least once. For instance, we get the sequence 'ab' with probability 1/4, 'bbab' with probability 1/16, and 'aab' with probability 1/8. Note, it's impossible for us to end with a sequence like 'aabab', since we would have stopped our algorithm once we had the prefix 'aab'. The expected amount of times that 'ab' will occur across all valid sequences is 2. For the second sample, the answer is equal to .

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

/**
 * @author Don Li
 */
public class NewYearArbitraryArrangement3 {

    int MOD = (int) 1e9 + 7;

    void solve() {
        int k = in.nextInt(), a = in.nextInt(), b = in.nextInt();

        int pa = (int) ((long) a * inv(a + b) % MOD);
        int pb = (int) ((long) b * inv(a + b) % MOD);

        int x = (int) ((long) pa * inv(pb) % MOD);

        int[][] dp = new int[k][k + 1];
        for (int i = k - 1; i >= 0; i--) {
            for (int j = k; j >= 1; j--) {
                if (i + j >= k) {
                    dp[i][j] = (i + j + x) % MOD;
                    continue;
                }
                dp[i][j] = (int) ((dp[i][j] + (long) dp[i][j + 1] * pa % MOD) % MOD);
                dp[i][j] = (int) ((dp[i][j] + (long) dp[i + j][j] * pb % MOD) % MOD);
            }
        }
        out.println(dp[0][1]);
    }

    int inv(int x) {
        if (x == 1) return 1;
        return (int) ((long) (MOD - MOD / x) * inv(MOD % x) % MOD);
    }

    public static void main(String[] args) {
        in = new FastScanner(new BufferedReader(new InputStreamReader(System.in)));
        out = new PrintWriter(System.out);
        new NewYearArbitraryArrangement3().solve();
        out.close();
    }

    static FastScanner in;
    static PrintWriter out;

    static class FastScanner {
        BufferedReader in;
        StringTokenizer st;

        public FastScanner(BufferedReader in) {
            this.in = in;
        }

        public String nextToken() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(in.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

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

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

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Junior
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskD solver = new TaskD();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskD {
        long MOD = (int) 1e9 + 7;
        int k;
        int a;
        int b;
        long ia;
        long ib;
        long iab;
        long pa;
        long pb;
        long[][] dp;

        public void solve(int testNumber, InputReader in, OutputWriter out) {
            k = in.nextInt();
            a = in.nextInt();
            b = in.nextInt();
            ia = MathUtils.invMod(a, MOD);
            ib = MathUtils.invMod(b, MOD);
            iab = (int) MathUtils.invMod(MathUtils.addMod(a, b, MOD), MOD);
            dp = new long[k + 1][k + 1];
            pa = MathUtils.mulMod(a, iab, MOD);
            pb = MathUtils.mulMod(b, iab, MOD);
            for (int i = 0; i < k; ++i) dp[k][i] = (1l * i + k + a * ib) % MOD;
            for (int i = k - 1; i >= 1; --i) {
                for (int j = k - 1; j >= 0; --j) {
                    long sa = MathUtils.mulMod(pa, dp[i + 1][j], MOD);
                    long sb = MathUtils.mulMod(pb, ((i + j >= k) ? i + j : dp[i][i + j]), MOD);
                    dp[i][j] = MathUtils.addMod(sa, sb, MOD);
                }
            }
            out.println(dp[1][0]);
        }

    }

    static class MathUtils {
        public static long addMod(long a, long b, long md) {
            return (a + b) % md;
        }

        public static long mulMod(long a, long b, long md) {
            return (a * b) % md;
        }

        public static long powMod(long b, long p, long md) {
            long ans = 1;
            while (p > 0) {
                if ((p & 1) > 0) ans = mulMod(ans, b, md);
                p >>= 1;
                b = mulMod(b, b, md);
            }
            return ans;
        }

        public static long invMod(long x, long p) { //only if p is prime
            return powMod(x, p - 2, p);
        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

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

        public void println(long i) {
            writer.println(i);
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int nextInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Junior
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskD solver = new TaskD();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskD {
        long MOD = (int) 1e9 + 7;
        int k;
        int a;
        int b;
        long ia;
        long ib;
        long iab;
        long pa;
        long pb;
        long[][] dp;

        public void solve(int testNumber, InputReader in, OutputWriter out) {
            k = in.nextInt();
            a = in.nextInt();
            b = in.nextInt();
            ia = MathUtils.invMod(a, MOD);
            ib = MathUtils.invMod(b, MOD);
            iab = (int) MathUtils.invMod(MathUtils.addMod(a, b, MOD), MOD);
            dp = new long[k + 1][k + 1];
            pa = MathUtils.mulMod(a, iab, MOD);
            pb = MathUtils.mulMod(b, iab, MOD);
            for (int i = 0; i < k; ++i) dp[k][i] = (1l * i + k + a * ib) % MOD;
            for (int i = k - 1; i >= 1; --i) {
                for (int j = k - 1; j >= 0; --j) {
                    dp[i][j] = ((pa * dp[i + 1][j]) + (pb * ((i + j >= k) ? i + j : dp[i][i + j]))) % MOD;
                }
            }
            out.println(dp[1][0]);
        }

    }

    static class MathUtils {
        public static long addMod(long a, long b, long md) {
            return (a + b) % md;
        }

        public static long mulMod(long a, long b, long md) {
            return (a * b) % md;
        }

        public static long powMod(long b, long p, long md) {
            long ans = 1;
            while (p > 0) {
                if ((p & 1) > 0) ans = mulMod(ans, b, md);
                p >>= 1;
                b = mulMod(b, b, md);
            }
            return ans;
        }

        public static long invMod(long x, long p) { //only if p is prime
            return powMod(x, p - 2, p);
        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

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

        public void println(long i) {
            writer.println(i);
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int nextInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Junior
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskD solver = new TaskD();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskD {
        long MOD = (int) 1e9 + 7;

        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int k = in.nextInt();
            int a = in.nextInt();
            int b = in.nextInt();
            long ia = MathUtils.invMod(a, MOD);
            long ib = MathUtils.invMod(b, MOD);
            long iab = MathUtils.invMod(MathUtils.addMod(a, b, MOD), MOD);
            long[][] dp = new long[k + 1][k + 1];
            long pa = MathUtils.mulMod(a, iab, MOD);
            long pb = MathUtils.mulMod(b, iab, MOD);
            for (int i = 0; i < k; ++i) dp[k][i] = (1l * i + k + a * ib) % MOD;
            for (int i = k - 1; i >= 1; --i) {
                for (int j = k - 1; j >= 0; --j) {
                    long sa = MathUtils.mulMod(pa, dp[i + 1][j], MOD);
                    long sb = MathUtils.mulMod(pb, ((i + j >= k) ? i + j : dp[i][i + j]), MOD);
                    dp[i][j] = MathUtils.addMod(sa, sb, MOD);
                }
            }
            out.println(dp[1][0]);
        }

    }

    static class MathUtils {
        public static long addMod(long a, long b, long md) {
            return (a + b) % md;
        }

        public static long mulMod(long a, long b, long md) {
            return (a * b) % md;
        }

        public static long powMod(long b, long p, long md) {
            long ans = 1;
            while (p > 0) {
                if ((p & 1) > 0) ans = mulMod(ans, b, md);
                p >>= 1;
                b = mulMod(b, b, md);
            }
            return ans;
        }

        public static long invMod(long x, long p) { //only if p is prime
            return powMod(x, p - 2, p);
        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

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

        public void println(long i) {
            writer.println(i);
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int nextInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }
}

/**
 * @author derrick20
 */
import java.io.*;
import java.util.*;

public class ArbitraryArrangementREDO {

    static long mod = (long) 1e9 + 7;
    public static void main(String args[]) throws Exception {
        FastScanner sc = new FastScanner();
        PrintWriter out = new PrintWriter(System.out);

        int K = sc.nextInt();
        long a = sc.nextLong();
        long b = sc.nextLong();
        long denom = fastExpo(a + b, mod - 2);
        long pA = (a * denom) % mod;
        long pB = (b * denom) % mod;
        long pBinv = fastExpo(pB, mod - 2);

        long[][] dp = new long[K + 1][K + 1];
        // dp[a][ab] = expected number of ab's from this state until termination
        // we already know the expected value is >= K
        // so, let's have the dp values store the number of ADDITIONAL ABs that will
        // occur upon termination (K + dp)

        for (int aCount = K; aCount >= 1; aCount--) {
            for (int abCount = K; abCount >= 0; abCount--) {
                if (abCount == K) {
                    dp[aCount][abCount] = K; // since we've already arrived there, base case
                }
                else {
                    // otherwise, we can add an A or B here.

                    // Morphed version of a base case:
                    if (aCount + abCount >= K) {
                        // from here, we can add any amount of As, followed by a B
                        // Essentially, this is the key trick that allows us to COMPRESS
                        // the infinite DP space into K^2. After our a + ab count >= K,
                        // I can say for certain the structure of the remaining sequeunce (AAA...B)
                        // So, once this happens, we don't need to rely on future DP state values,
                        // I can just give the value directly using infinite series!
                        int given = aCount + abCount;
                        dp[aCount][abCount] = add(given, multiply(pA, pBinv));
                    }
                    else {
                        // If we haven't reached that case above, then we need to RELY ON
                        // OTHER DP STATES that will have been computed already (we are
                        // progressing downwards, PULL-DP

                        // Add a B
                        dp[aCount][abCount] = add(dp[aCount][abCount], multiply(pB, dp[aCount][aCount + abCount]));

                        // Add an A
                        // Note that we won't worry about the aCount going out of bounds, since
                        // the above inequality GUARANTEES aCount < K - abCount
                        // at worst case, aCount < K still!
                        dp[aCount][abCount] = add(dp[aCount][abCount], multiply(pA, dp[aCount + 1][abCount]));
                    }

                }
            }
        }

//        for (int i = 0; i <= K; i++) {
//            System.out.println(Arrays.toString(dp[i]));
//        }
        // E(0, 0) = pA * E(1, 0) + pB * (E(0, 0)
        // E(0, 0) * (1 - pB) = pA * E(1, 0)
        // E(0, 0) = E(1, 0)
        long answer = dp[1][0];
        out.println(answer);
        out.close();
    }

    static long add(long a, long b) {
        long s = a + b;
        return s % mod;
    }

    static long multiply(long a, long b) {
        return (a * b) % mod;
    }

    static long fastExpo(long x, long k) {
        if (k == 0) {
            return 1;
        }
        else if (k == 1) {
            return x;
        }
        else {
            long root = fastExpo(x, k / 2);
            long ans = (root * root) % mod;
            if (k % 2 == 1) {
                ans = (x * ans) % mod;
            }
            return ans;
        }
    }

    static class FastScanner {
        public int BS = 1<<16;
        public char NC = (char)0;
        byte[] buf = new byte[BS];
        int bId = 0, size = 0;
        char c = NC;
        double cnt = 1;
        BufferedInputStream in;

        public FastScanner() {
            in = new BufferedInputStream(System.in, BS);
        }

        public FastScanner(String s) {
            try {
                in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
            }
            catch (Exception e) {
                in = new BufferedInputStream(System.in, BS);
            }
        }

        private char getChar(){
            while(bId==size) {
                try {
                    size = in.read(buf);
                }catch(Exception e) {
                    return NC;
                }
                if(size==-1)return NC;
                bId=0;
            }
            return (char)buf[bId++];
        }

        public int nextInt() {
            return (int)nextLong();
        }

        public int[] nextInts(int N) {
            int[] res = new int[N];
            for (int i = 0; i < N; i++) {
                res[i] = (int) nextLong();
            }
            return res;
        }

        public long[] nextLongs(int N) {
            long[] res = new long[N];
            for (int i = 0; i < N; i++) {
                res[i] = nextLong();
            }
            return res;
        }

        public long nextLong() {
            cnt=1;
            boolean neg = false;
            if(c==NC)c=getChar();
            for(;(c<'0' || c>'9'); c = getChar()) {
                if(c=='-')neg=true;
            }
            long res = 0;
            for(; c>='0' && c <='9'; c=getChar()) {
                res = (res<<3)+(res<<1)+c-'0';
                cnt*=10;
            }
            return neg?-res:res;
        }

        public double nextDouble() {
            double cur = nextLong();
            return c!='.' ? cur:cur+nextLong()/cnt;
        }

        public String next() {
            StringBuilder res = new StringBuilder();
            while(c<=32)c=getChar();
            while(c>32) {
                res.append(c);
                c=getChar();
            }
            return res.toString();
        }

        public String nextLine() {
            StringBuilder res = new StringBuilder();
            while(c<=32)c=getChar();
            while(c!='\n') {
                res.append(c);
                c=getChar();
            }
            return res.toString();
        }

        public boolean hasNext() {
            if(c>32)return true;
            while(true) {
                c=getChar();
                if(c==NC)return false;
                else if(c>32)return true;
            }
        }
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

public class d {

	static long k, dp[][], rpa, rpb, mod, pa, pb, jump;

	static long go(int as, int seq) {
		if(seq >= k) return 0;
		if(as + seq >= k)
			return as + seq + jump;
		if(dp[as][seq] != -1)
			return dp[as][seq];

		long bval = go(as, seq + as) * rpb % mod;
		long aval = go(as + 1, seq) * rpa % mod;
		return dp[as][seq] = (bval + aval) % mod;
	}

	public static void main(String args[]) throws IOException {
		FastScanner in = new FastScanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		// BEGIN HERE
		mod = (long) 1e9 + 7;
		k = in.nextLong();
		pa = in.nextLong();
		pb = in.nextLong();

		rpa = pa * combinatorics.modInv(pa+pb, mod) % mod;
		rpb = pb * combinatorics.modInv(pa+pb, mod) % mod;

		jump = (combinatorics.modInv(rpb, mod) - 1) + mod % mod;
		dp = new long[(int)k+1][(int)k + 1];
		for(int i = 0; i < k+1 ; i++) {
			Arrays.fill(dp[i], -1);
		}
		System.out.println(go(1,0));
		out.close();
	}

	static class FastScanner {
		BufferedReader br;
		StringTokenizer st;

		public FastScanner(InputStream i) {
			br = new BufferedReader(new InputStreamReader(i));
			st = null;
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public String nextLine() throws IOException {
			if (st == null) {
				st = new StringTokenizer(br.readLine());
			}
			String line = st.nextToken("\n");
			st = null;
			return line;
		}

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

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

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

	public static class combinatorics {
		static long modInv(long a, long b) {
			return 1 < a ? b - modInv(b % a, a) * b / a : 1;
		}

		static long factorial[], mod;

		combinatorics(int n, long MOD) {
			mod = MOD;
			factorial = new long[n + 1];
			factorial[0] = 1;
			for (int i = 1; i <= n; i++) {
				factorial[i] = i * factorial[i - 1];
				factorial[i] %= mod;
			}
		}

		static long nCr(int n, int r) {
			if (r > n)
				return 0;
			return (factorial[n] * modInv((factorial[n - r] * factorial[r]) % mod, mod)) % mod;
		}

		static long gcd(long a, long b) {
			return b == 0 ? a : gcd(b, a % b);
		}

		static long lcm(long a, long b) {
			return a * (b / gcd(a, b));
		}
	}

	public static class DisjointSet {
		int p[], r[], s[];
		int numDisjoint;

		DisjointSet(int N) {
			numDisjoint = N;
			r = new int[N];
			s = new int[N];
			p = new int[N];
			for (int i = 0; i < N; i++)
				p[i] = i;
		}

		int findSet(int i) {
			return (p[i] == i) ? i : (p[i] = findSet(p[i]));
		}

		boolean isSameSet(int i, int j) {
			return findSet(i) == findSet(j);
		}

		void unionSet(int i, int j) {
			if (!isSameSet(i, j)) // if from different set
			{
				numDisjoint--;
				int x = findSet(i), y = findSet(j);
				if (r[x] > r[y]) {
					p[y] = x; // rank keeps the tree short
					s[x] += s[y];
				} else {
					p[x] = y;
					if (r[x] == r[y])
						r[y]++;
					s[y] += s[x];
				}
			}
		}

		int sizeOfSet(int i) {
			return s[findSet(i)];
		}
	};

}

import java.io.*;
import java.util.*;

public class Solution {
    static MyScanner sc;
    private static PrintWriter out;
    static long M2 = 1_000_000_000L + 7;

    public static void main(String[] s) throws Exception {
        StringBuilder stringBuilder = new StringBuilder();
        if (stringBuilder.length() == 0) {
            sc = new MyScanner(System.in);
        } else {
            sc = new MyScanner(new BufferedReader(new StringReader(stringBuilder.toString())));
        }

        out = new PrintWriter(new OutputStreamWriter(System.out));
        initData();
        solve();
        out.flush();
    }

    private static void initData() {
    }

    private static void solve() throws IOException {

        int k = sc.nextInt();
        int a = sc.nextInt();
        int b = sc.nextInt();

        long in = pow(a + b, M2 - 2, M2);

        long va = (a * in) % M2;
        long vb = (b * in) % M2;

        long[][] resk = new long[k][k + 1];

        long bpoison = (a * pow(b, M2 - 2, M2)) % M2;

        resk[0][1] = 1;

        long res = 0;
        for (int t = 0; t < k; t++) {
            for (int x = 1; x < k; x++) {
                resk[t][x + 1] += (resk[t][x] * va) % M2;
                resk[t][x + 1] %= M2;
                if (t + x >= k) {
                    long tt = (resk[t][x] * vb) % M2;
                    tt *= (t + x);
                    res += tt % M2;
                } else {
                    resk[t + x][x] += resk[t][x] * vb % M2;
                    resk[t + x][x] %= M2;
                }
            }
        }

        for (int l = 0; l < k; l++) {
            res += ((l + k) * resk[l][k]) % M2;
            res += (resk[l][k] * bpoison) % M2;
            res %= M2;
        }

        out.println(res);
    }

    private static void solveT() throws IOException {
        int t = sc.nextInt();
        while (t-- > 0) {
            solve();
        }
    }

    private static long gcd(long l, long l1) {
        if (l > l1) return gcd(l1, l);
        if (l == 0) return l1;
        return gcd(l1 % l, l);
    }

    private static long pow(long a, long b, long m) {
        if (b == 0) return 1;
        if (b == 1) return a;
        long pp = pow(a, b / 2, m);
        pp *= pp;
        pp %= m;
        return (pp * (b % 2 == 0 ? 1 : a)) % m;
    }

    static class MyScanner {
        BufferedReader br;
        StringTokenizer st;

        MyScanner(BufferedReader br) {
            this.br = br;
        }

        public MyScanner(InputStream in) {
            this(new BufferedReader(new InputStreamReader(in)));
        }

        void findToken() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }

        String next() {
            findToken();
            return st.nextToken();
        }

        Integer[] nab(int n) {
            Integer[] k = new Integer[n];
            for (int i = 0; i < n; i++) {
                k[i] = sc.fi();
            }
            return k;
        }

        int[] na(int n) {
            int[] k = new int[n];
            for (int i = 0; i < n; i++) {
                k[i] = sc.fi();
            }
            return k;
        }

        long[] nl(int n) {
            long[] k = new long[n];
            for (int i = 0; i < n; i++) {
                k[i] = sc.nextLong();
            }
            return k;
        }

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

        int fi() {
            String t = next();
            int cur = 0;
            boolean n = t.charAt(0) == '-';
            for (int a = n ? 1 : 0; a < t.length(); a++) {
                cur = cur * 10 + t.charAt(a) - '0';
            }
            return n ? -cur : cur;
        }

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

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

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Scanner;
import java.util.*;

public class Main {

    static int K, pA, pB;
    static long totInv, invB;
    static int [][] dp;
    static final int M = (int) 1e9 + 7;
    static long pBinv;

    static int solve(int as, int k) {
        // at least K
        if(k >= K)
            return k;
        if(as >= K) {
           return (int) ((1l * pBinv + as + k - 1 + M) % M);
        }
        if(dp[as][k] != -1)
            return dp[as][k];
        // put a
        long ansA = 1l * pA * solve(as + 1, k) % M * totInv % M;
        // put b
        long ansB = 1l * pB * solve(as, k + as) % M * totInv % M;

        return dp[as][k] = (int)((ansA + ansB) % M);
    }

    static long modPow(long a, long e) {

        long res = 1;
        while(e > 0) {
            if((e & 1) == 1)
                res = (res * a) % M;
            a = (a * a) % M;
            e >>= 1;
        }

        return res % M;
    }

    static void build() {
        totInv = (int) modPow((pA + pB), M - 2);
        invB = (int) modPow(pB, M - 2);
        for(int i = 0; i <= 1002; ++i)
            Arrays.fill(dp[i], -1);

        pBinv = 1l * (pA + pB) * invB % M;
    }

    public static void main(String[] args) throws IOException{
        Scanner sc = new Scanner();
        PrintWriter out = new PrintWriter(System.out);
        K = sc.nextInt();
        pA = sc.nextInt();
        pB = sc.nextInt();
        dp = new int[1003][1003];
        build();
        System.out.println(solve(1, 0));
    }

    static class Scanner {
        BufferedReader br;
        StringTokenizer st;

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

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

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

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

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

        String nextLine() throws IOException {
            return br.readLine();
        }

    }
    }

import java.io.*;
import java.util.*;
public class DD {
	public static void main(String[] args)throws Throwable {
		MyScanner sc=new MyScanner();
		PrintWriter pw=new PrintWriter(System.out);

		k=sc.nextInt();
		pa=sc.nextInt();
		pb=sc.nextInt();
		invB=inv(pb);
		invAB=inv(pa+pb);
		mem=new long [k+1][k+1];
		for(long [] x : mem)
			Arrays.fill(x, -1);
		pw.println(dp(1, 0));
		pw.flush();
		pw.close();
	}
	static long invAB,invB;
	static int k;
	static long pa,pb;
	static long [][] mem;

	static long dp(int i,int j){
		if(j>=k){
			return j;
		}
		if(i==k){
			long ret=pa*invB%mod;
			ret=(ret+k+j)%mod;
			return ret;
		}
		if(mem[i][j]!=-1)
			return mem[i][j];
		long ans=pa*dp(i+1, j)%mod;
		ans+=pb*dp(i, j+i)%mod;
		ans%=mod;
		ans=(ans*invAB)%mod;
		return mem[i][j]=ans;
	}

	static long mod=(int)(1e9+7);

	public static long inv(long x){
		long r,y;
		for(r=1,y=mod-2;y!=0;x=x*x%mod,y>>=1)
			if((y&1)==1)
				r=r*x%mod;
		return r;
	}

	static class MyScanner {
		BufferedReader br;
		StringTokenizer st;
		public MyScanner() {
			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;}
	}
}

import java.util.*;
import java.math.*;
public class D {
	static long am,bm,en;
	static long mod = (long)(1e9+7);
	static int k;
	static long[][] memo;
	public static void main(String[] args) {
		Scanner qwe = new Scanner(System.in);
		k = qwe.nextInt();
		int pa = qwe.nextInt();
		int pb = qwe.nextInt();

		long dem = new BigInteger((pa+pb)+"").modInverse(new BigInteger(mod+"")).longValue();
		am = pa*dem%mod;
		bm = pb*dem%mod;

		en = new BigInteger((pb)+"").modInverse(new BigInteger(mod+"")).longValue();
		en *= pa;
		en %= mod;

		//System.out.println(am + " " + bm + " " + en);

		memo = new long[k+1][k+1];
		for (int i = 0; i < memo.length; i++) {
			Arrays.fill(memo[i], -1);
		}

		System.out.println(dp(0,0));
	}

	static long dp(int as, int subs){
		if(subs+as >= k){
			return subs+as+en;
		}
		if(memo[as][subs] != -1) return memo[as][subs];
		if(as == 0){
			return memo[as][subs] = dp(as+1,subs)%mod;
		}
		else{
			long bcount =bm*(dp(as,subs+as))%mod;
			return memo[as][subs] = (am*dp(as+1,subs)%mod+bcount)%mod;
		}
	}

}

import java.io.*;
import java.util.*;

public class Codeforces908D {
	public static void main(String[] args) throws IOException {
		//BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		//String[] sp = br.readLine().split(" ");
		Scanner input = new Scanner(System.in);
		int k = input.nextInt();//Integer.parseInt(sp[0]);
		int a = input.nextInt();//Integer.parseInt(sp[1]);
		int b = input.nextInt();//Integer.parseInt(sp[2]);

		int[][] exact = new int[k+1][k+1];
		int[][] atleast = new int[k+1][k+1];

		for (int i = 1; i <= k; i++) {
			exact[i][i] = 0;
			atleast[i][i] = multiply(a, inverse(b, 1000000007));

			for (int j = i-1; j > 0; j--) {
				if (j <= i-j)
					exact[i][j] = atleast[i-j][j];
				else
					exact[i][j] = atleast[i-j][i-j]+2*j-i;
				atleast[i][j] = (multiply(multiply(b, inverse(a+b, 1000000007)), exact[i][j]) + multiply(multiply(a, inverse(a+b, 1000000007)), atleast[i][j+1]))%1000000007;
			}
		}

		System.out.println((k+atleast[k][1])%1000000007);
		input.close();
	}

	public static int multiply (int a, int b) {
		long c = (long) a;
		long d = (long) b;
		long e = (c*d)%1000000007;
		return ((int) e);
	}

	public static int inverse (int a, int n) {
		int m = n;
		int r1 = 1;
		int r2 = 0;
		int r3 = 0;
		int r4 = 1;
		while ((a > 0) && (n > 0)) {
			if (n >= a) {
				r3 -= r1*(n/a);
				r4 -= r2*(n/a);
				n = n%a;
			}
			else {
				int tmp = a;
				a = n;
				n = tmp;
				tmp = r1;
				r1 = r3;
				r3 = tmp;
				tmp = r2;
				r2 = r4;
				r4 = tmp;
			}
		}
		if (a == 0) {
			if (r3 >= 0)
				return (r3%m);
			else
				return (m+(r3%m));
		}
		else {
			if (r1 >= 0)
				return (r1%m);
			else
				return (m+(r1%m));
		}

	}
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Pradyumn
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastReader in = new FastReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskD solver = new TaskD();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskD {
        final long MODULO = (long) (1e9 + 7);

        long pow(long a, long n) {
            if (n == 0) return 1;
            if (n % 2 == 0) return pow(a * a % MODULO, n >> 1);
            return a * pow(a, n - 1) % MODULO;
        }

        long inverse(long a) {
            return pow(a, MODULO - 2);
        }

        public void solve(int testNumber, FastReader in, PrintWriter out) {
            int k = in.nextInt();
            int pa = in.nextInt();
            int pb = in.nextInt();
            long pra = pa * inverse(pa + pb) % MODULO;
            long prb = pb * inverse(pa + pb) % MODULO;
            long invpra = inverse(pra);
            long invprb = inverse(prb);
            long[][] expect = new long[k + 1][];
            for (int togo = 1; togo <= k; ++togo) {
                expect[togo] = new long[togo + 1];
                expect[togo][togo] = (togo + (1 - prb + MODULO) * invprb) % MODULO;
                for (int have = togo - 1; have >= 0; --have) {
                    expect[togo][have] = (expect[togo][have] + (have == 0 ? 1 : pra) * expect[togo][have + 1]) % MODULO;
                    if (have > 0) {
                        int ntogo = togo - have;
                        int extra = have;
                        int nhave = have;
                        if (have > ntogo) {
                            extra += have - ntogo;
                            nhave = ntogo;
                        }
                        expect[togo][have] = (expect[togo][have] + prb * (extra + expect[ntogo][nhave])) % MODULO;
                    }
                }
            }
            out.println(expect[k][0]);
        }

    }

    static class FastReader {
        private InputStream stream;
        private byte[] buf = new byte[8192];
        private int curChar;
        private int pnumChars;

        public FastReader(InputStream stream) {
            this.stream = stream;
        }

        private int pread() {
            if (pnumChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= pnumChars) {
                curChar = 0;
                try {
                    pnumChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (pnumChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int nextInt() {
            int c = pread();
            while (isSpaceChar(c))
                c = pread();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = pread();
            }
            int res = 0;
            do {
                if (c == ',') {
                    c = pread();
                }
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = pread();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        private boolean isSpaceChar(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Pradyumn
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastReader in = new FastReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskD solver = new TaskD();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskD {
        static final long MODULO = (long) (1e9 + 7);

        long pow(long a, long n) {
            if (n == 0)
                return 1;
            if (n % 2 == 0) return pow(a * a % MODULO, n >> 1);
            return a * pow(a, n - 1) % MODULO;
        }

        long inv(long a) {
            return pow(a, MODULO - 2);
        }

        public void solve(int testNumber, FastReader in, PrintWriter out) {
            int k = in.nextInt();
            int pa = in.nextInt();
            int pb = in.nextInt();
            long pra = pa * inv(pa + pb) % MODULO;
            long prb = pb * inv(pa + pb) % MODULO;
            long invpra = inv(pra);
            long invprb = inv(prb);
            int[][] expect = new int[k + 1][];
            for (int togo = 1; togo <= k; ++togo) {
                expect[togo] = new int[togo + 1];
                expect[togo][togo] = (int) ((togo + (1 - prb + MODULO) * invprb) % MODULO);
                for (int have = togo - 1; have >= 0; --have) {
                    {
                        // get a
                        expect[togo][have] = (int) ((expect[togo][have] + (have == 0 ? 1 : pra) * expect[togo][have + 1]) % MODULO);
                    }
                    if (have > 0) {
                        // get b
                        int ntogo = togo - have;
                        int extra = have;
                        int nhave = have;
                        if (have > ntogo) {
                            extra += have - ntogo;
                            nhave = ntogo;
                        }
                        expect[togo][have] = (int) ((expect[togo][have] + prb * (extra + expect[ntogo][nhave])) % MODULO);
                    }
                }
            }
            out.println(expect[k][0]);
        }

    }

    static class FastReader {
        private InputStream stream;
        private byte[] buf = new byte[8192];
        private int curChar;
        private int pnumChars;

        public FastReader(InputStream stream) {
            this.stream = stream;
        }

        private int pread() {
            if (pnumChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= pnumChars) {
                curChar = 0;
                try {
                    pnumChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (pnumChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int nextInt() {
            int c = pread();
            while (isSpaceChar(c))
                c = pread();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = pread();
            }
            int res = 0;
            do {
                if (c == ',') {
                    c = pread();
                }
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = pread();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        private boolean isSpaceChar(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Pradyumn
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastReader in = new FastReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskD solver = new TaskD();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskD {
        static final int MOD = 1000000007;

        static int add(int a, int b) {
            int res = a + b;
            return res >= MOD ? res - MOD : res;
        }

        static int mul(int a, int b) {
            int res = (int) ((long) a * b % MOD);
            return res < 0 ? res + MOD : res;
        }

        static int pow(int a, int e) {
            if (e == 0) {
                return 1;
            }
            int r = a;
            for (int i = 30 - Integer.numberOfLeadingZeros(e); i >= 0; i--) {
                r = mul(r, r);
                if ((e & (1 << i)) != 0) {
                    r = mul(r, a);
                }
            }
            return r;
        }

        static int inv(int a) {
            return pow(a, MOD - 2);
        }

        public void solve(int testNumber, FastReader in, PrintWriter out) {
            int k = in.nextInt();
            int pa = in.nextInt();
            int pb = in.nextInt();
            int den = inv(pa + pb);
            pa = mul(pa, den);
            pb = mul(pb, den);
            int ans = mul(pa, inv(pb));
            if (k == 1) {
                out.print(add(ans, 1));
                return;
            }
            int dyn[] = new int[k - 1];
            int ndyn[] = new int[k - 2];
            dyn[0] = 1;
            for (int a = 1; a < k; a++) {
                ArrayUtils.fill(ndyn, 0);
                for (int c = 0; c < k - a; c++) {
                    int v = mul(pa, dyn[c]);
                    if (a + c + 1 >= k) {
                        ans = add(ans, mul(v, a + c + 1));
                    } else {
                        ndyn[c] = v;
                    }
                    v = mul(pb, dyn[c]);
                    if (a + c + a >= k) {
                        ans = add(ans, mul(v, a + c + a));
                    } else {
                        dyn[c + a] = add(dyn[c + a], v);
                    }
                }
                int t[] = dyn;
                dyn = ndyn;
                ndyn = t;
            }
            out.print(ans);
        }

    }

    static class FastReader {
        private InputStream stream;
        private byte[] buf = new byte[8192];
        private int curChar;
        private int pnumChars;

        public FastReader(InputStream stream) {
            this.stream = stream;
        }

        private int pread() {
            if (pnumChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= pnumChars) {
                curChar = 0;
                try {
                    pnumChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (pnumChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int nextInt() {
            int c = pread();
            while (isSpaceChar(c))
                c = pread();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = pread();
            }
            int res = 0;
            do {
                if (c == ',') {
                    c = pread();
                }
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = pread();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        private boolean isSpaceChar(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

    }

    static class ArrayUtils {
        public static void fill(int[] array, int value) {
            Arrays.fill(array, value);
        }

    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Scanner;
import java.util.StringTokenizer;

public class ProblemD2 {
	static long MOD = 1000000007;

	public static void main(String[] args) {
		FastScanner input = new FastScanner();
		int k_final = input.nextInt();
		long pa = input.nextInt();
		long paInverse = BigInteger.valueOf(pa).modInverse(BigInteger.valueOf(MOD)).intValue();
		long pb = input.nextInt();
		long pbInverse = BigInteger.valueOf(pb).modInverse(BigInteger.valueOf(MOD)).intValue();
		long paPlusPb = pa+pb;
		long paPlusPbInverse = BigInteger.valueOf(paPlusPb).modInverse(BigInteger.valueOf(MOD)).intValue();
		int startA = 1;
		int startK = 0;
		long[][] dynamic = new long[k_final+1][k_final+1];
		dynamic[startA][startK] = 1;
		for(int aPlusK = 1; aPlusK < k_final; aPlusK++) {
			for(int a = 1; a <= aPlusK; a++) {
				int k = aPlusK-a;
				dynamic[a+1][k] += (((dynamic[a][k]*pa)%MOD)*paPlusPbInverse)%MOD;
				dynamic[a+1][k] %= MOD;
				dynamic[a][k+a] += (((dynamic[a][k]*pb)%MOD)*paPlusPbInverse)%MOD;
				dynamic[a][k+a] %= MOD;
			}
		}
		long EV = 0;
		for(int a = 0; a < k_final+1; a++) {
			for(int k = 0; k < k_final+1; k++) {
				if(a+k >= k_final) {
					long probability = dynamic[a][k];
					long number_of_k = a+k+((pa)*(pbInverse))%MOD;
					long ev2 = probability*number_of_k%MOD;
					EV += ev2;
					EV %= MOD;
				}
			}
		}
		System.out.println(EV);

	}

	public static class FastScanner {
		BufferedReader br;
		StringTokenizer st;

		public FastScanner(Reader in) {
			br = new BufferedReader(in);
		}

		public FastScanner() {
			this(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 readNextLine() {
			String str = "";
			try {
				str = br.readLine();
			} catch (IOException e) {
				e.printStackTrace();
			}
			return str;
		}

		int[] readIntArray(int n) {
			int[] a = new int[n];
			for (int idx = 0; idx < n; idx++) {
				a[idx] = nextInt();
			}
			return a;
		}

		long[] readLongArray(int n) {
			long[] a = new long[n];
			for (int idx = 0; idx < n; idx++) {
				a[idx] = nextLong();
			}
			return a;
		}
	}
}

import java.io.*;
import java.math.BigInteger;
import java.util.*;

public class Solution {

    public static void main(String[] args) throws Exception {
        MyReader reader = new MyReader(System.in);
//        MyReader reader = new MyReader(new FileInputStream("input.txt"));
        MyWriter writer = new MyWriter(System.out);
        new Solution().run(reader, writer);
        writer.close();
    }

    private void run(MyReader reader, MyWriter writer) throws IOException {
        int k = reader.nextInt();
        int a = reader.nextInt();
        int b = reader.nextInt();
        long mod = 1_000_000_007;
        long a1 = a * f(a + b) % mod;
        long b1 = b * f(a + b) % mod;
        long qq = a * f(b) % mod;
        long[][] d = new long[k + 1][k];
        d[1][0] = 1;
        for (int i = 1; i < k; i++) {
            for (int j = 0; j < k; j++) {
                d[i + 1][j] = (d[i + 1][j] + d[i][j] * a1) % mod;
                if (i + j < k) {
                    d[i][i + j] = (d[i][i + j] + d[i][j] * b1) % mod;
                }
            }
        }
        long ans = 0;
        for (int i = 1; i < k; i++) {
            for (int j = k - i; j < k; j++) {
                ans = (ans + (i + j) * d[i][j] % mod * b1) % mod;
            }
        }
        for (int i = 0; i < k; i++) {
            ans = (ans + d[k][i] * (i + k + qq)) % mod;
        }
        writer.print(ans);
    }

    private BigInteger bb = new BigInteger("-1");
    private BigInteger mod = new BigInteger("1000000007");

    private long f(long a) {
        BigInteger q = new BigInteger(a + "");
        return q.modPow(bb, mod).longValue();
    }

    static class MyReader {

        final BufferedInputStream in;
        final int bufSize = 1 << 16;
        final byte buf[] = new byte[bufSize];
        int i = bufSize;
        int k = bufSize;
        boolean end = false;
        final StringBuilder str = new StringBuilder();

        MyReader(InputStream in) {
            this.in = new BufferedInputStream(in, bufSize);
        }

        int nextInt() throws IOException {
            return (int) nextLong();
        }

        int[] nextIntArray(int n) throws IOException {
            int[] m = new int[n];
            for (int i = 0; i < n; i++) {
                m[i] = nextInt();
            }
            return m;
        }

        int[][] nextIntMatrix(int n, int m) throws IOException {
            int[][] a = new int[n][0];
            for (int j = 0; j < n; j++) {
                a[j] = nextIntArray(m);
            }
            return a;
        }

        long nextLong() throws IOException {
            int c;
            long x = 0;
            boolean sign = true;
            while ((c = nextChar()) <= 32) ;
            if (c == '-') {
                sign = false;
                c = nextChar();
            }
            if (c == '+') {
                c = nextChar();
            }
            while (c >= '0') {
                x = x * 10 + (c - '0');
                c = nextChar();
            }
            return sign ? x : -x;
        }

        long[] nextLongArray(int n) throws IOException {
            long[] m = new long[n];
            for (int i = 0; i < n; i++) {
                m[i] = nextLong();
            }
            return m;
        }

        int nextChar() throws IOException {
            if (i == k) {
                k = in.read(buf, 0, bufSize);
                i = 0;
            }
            return i >= k ? -1 : buf[i++];
        }

        String nextString() throws IOException {
            if (end) {
                return null;
            }
            str.setLength(0);
            int c;
            while ((c = nextChar()) <= 32 && c != -1) ;
            if (c == -1) {
                end = true;
                return null;
            }
            while (c > 32) {
                str.append((char) c);
                c = nextChar();
            }
            return str.toString();
        }

        String nextLine() throws IOException {
            if (end) {
                return null;
            }
            str.setLength(0);
            int c = nextChar();
            while (c != '\n' && c != '\r' && c != -1) {
                str.append((char) c);
                c = nextChar();
            }
            if (c == -1) {
                end = true;
                if (str.length() == 0) {
                    return null;
                }
            }
            if (c == '\r') {
                nextChar();
            }
            return str.toString();
        }

        char[] nextCharArray() throws IOException {
            return nextString().toCharArray();
        }

        char[][] nextCharMatrix(int n) throws IOException {
            char[][] a = new char[n][0];
            for (int i = 0; i < n; i++) {
                a[i] = nextCharArray();
            }
            return a;
        }
    }

    static class MyWriter {

        final BufferedOutputStream out;
        final int bufSize = 1 << 16;
        final byte buf[] = new byte[bufSize];
        int i = 0;
        final byte c[] = new byte[30];
        static final String newLine = System.getProperty("line.separator");

        MyWriter(OutputStream out) {
            this.out = new BufferedOutputStream(out, bufSize);
        }

        void print(long x) throws IOException {
            int j = 0;
            if (i + 30 >= bufSize) {
                flush();
            }
            if (x < 0) {
                buf[i++] = (byte) ('-');
                x = -x;
            }
            while (j == 0 || x != 0) {
                c[j++] = (byte) (x % 10 + '0');
                x /= 10;
            }
            while (j-- > 0)
                buf[i++] = c[j];
        }

        void print(int[] m) throws IOException {
            for (int a : m) {
                print(a);
                print(' ');
            }
        }

        void print(long[] m) throws IOException {
            for (long a : m) {
                print(a);
                print(' ');
            }
        }

        void print(String s) throws IOException {
            for (int i = 0; i < s.length(); i++) {
                print(s.charAt(i));
            }
        }

        void print(char x) throws IOException {
            if (i == bufSize) {
                flush();
            }
            buf[i++] = (byte) x;
        }

        void print(char[] m) throws IOException {
            for (char c : m) {
                print(c);
            }
        }

        void println(String s) throws IOException {
            print(s);
            println();
        }

        void println() throws IOException {
            print(newLine);
        }

        void flush() throws IOException {
            out.write(buf, 0, i);
            out.flush();
            i = 0;
        }

        void close() throws IOException {
            flush();
            out.close();
        }
    }
}

import static java.lang.Integer.parseInt;
import static java.lang.Long.parseLong;
import static java.lang.System.exit;
import static java.util.Arrays.fill;

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

public class D {

	static final int MOD = 1000000007;

	static int add(int a, int b) {
		int res = a + b;
		return res >= MOD ? res - MOD : res;
	}

	static int sub(int a, int b) {
		int res = a - b;
		return res < 0 ? res + MOD : res;
	}

	static int mul(int a, int b) {
		int res = (int) ((long) a * b % MOD);
		return res < 0 ? res + MOD : res;
	}

	static int pow(int a, int e) {
		if (e == 0) {
			return 1;
		}
		int r = a;
		for (int i = 30 - Integer.numberOfLeadingZeros(e); i >= 0; i--) {
			r = mul(r, r);
			if ((e & (1 << i)) != 0) {
				r = mul(r, a);
			}
		}
		return r;
	}

	static int inv(int a) {
		return pow(a, MOD - 2);
	}

	static void solve() throws Exception {
		int k = scanInt();
		int pa = scanInt();
		int pb = scanInt();
		int den = inv(pa + pb);
		pa = mul(pa, den);
		pb = mul(pb, den);
		int ans = mul(pa, inv(pb));
		if (k == 1) {
			out.print(add(ans, 1));
			return;
		}
		int dyn[] = new int[k - 1];
		int ndyn[] = new int[k - 2];
		dyn[0] = 1;
		for (int a = 1; a < k; a++) {
			fill(ndyn, 0);
			for (int c = 0; c < k - a; c++) {
				int v = mul(pa, dyn[c]);
				if (a + c + 1 >= k) {
					ans = add(ans, mul(v, a + c + 1));
				} else {
					ndyn[c] = v;
				}
				v = mul(pb, dyn[c]);
				if (a + c + a >= k) {
					ans = add(ans, mul(v, a + c + a));
				} else {
					dyn[c + a] = add(dyn[c + a], v);
				}
			}
			int t[] = dyn;
			dyn = ndyn;
			ndyn = t;
		}
		out.print(ans);
	}

	static int scanInt() throws IOException {
		return parseInt(scanString());
	}

	static long scanLong() throws IOException {
		return parseLong(scanString());
	}

	static String scanString() throws IOException {
		while (tok == null || !tok.hasMoreTokens()) {
			tok = new StringTokenizer(in.readLine());
		}
		return tok.nextToken();
	}

	static BufferedReader in;
	static PrintWriter out;
	static StringTokenizer tok;

	public static void main(String[] args) {
		try {
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);
			solve();
			in.close();
			out.close();
		} catch (Throwable e) {
			e.printStackTrace();
			exit(1);
		}
	}
}

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

import java.io.*;
import java.util.*;

/**
 *
 * @author kamranmaharov
 */
public class Main {
    private static Quotient[][] dp = new Quotient[1001][1001];
    private static int k, pa, pb;
    private static int REM = 1000000007;
    private static Quotient q1, q2, q3;
    private static final Integer[] inverse = new Integer[1000001];

    private static class Quotient {
        private final int P, Q;

        Quotient(int P, int Q) {
            this.P = P;
            this.Q = inverse(Q);
        }

        public Quotient add(Quotient other) {
            return new Quotient(  (int)(((long)P*Q + (long)other.P*other.Q) % REM), 1);
        }

        public Quotient multiply(Quotient other) {
            return new Quotient((int)((long)P*Q%REM*other.P%REM*other.Q%REM), 1);
        }

        @Override
        public String toString() {
            return String.valueOf((long)P*Q % REM);
        }

        private static int inverse(int Q) {
            if (Q < inverse.length && inverse[Q] != null) {return inverse[Q];}
            int inv = pow(Q, REM-2);
            if (Q < inverse.length) {inverse[Q] = inv;}
            return inv;
        }

        private static int pow(int a, int b) {
            if (b==0) {return 1;}
            else if (b%2==1) {return (int)((long)pow(a,b-1) * a % REM);}
            else {
                int mid = pow(a,b/2);
                return (int)((long)mid*mid%REM);
            }
        }
    }

    private static Quotient f(int c1, int c2) {
        if (dp[c1][c2] != null) {
            return dp[c1][c2];
        }
        if (c1+c2>=k) {
            dp[c1][c2] = new Quotient(c1+c2, 1).add(q1);
        } else {
            dp[c1][c2] = f(c1, c2+1).multiply(q2).add(
                    f(c1+c2, c2).multiply(q3));
        }
        return dp[c1][c2];
    }

    public static void main(String[] args) throws Exception {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));

        String[] line = in.readLine().split(" ");
        k = Integer.parseInt(line[0]);
        pa = Integer.parseInt(line[1]);
        pb = Integer.parseInt(line[2]);
        q1 = new Quotient(pa, pb);
        q2 = new Quotient(pa, pa+pb);
        q3 = new Quotient(pb, pa+pb);

        out.write(f(0, 1).toString() + "\n");
        out.close();
    }
}

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

import java.io.*;
import java.util.*;

/**
 *
 * @author kamranmaharov
 */
public class Main {
    private static Quotient[][] dp = new Quotient[1001][1001];
    private static int k, pa, pb;
    private static int REM = 1000000007;
    private static final Integer[] inverse = new Integer[1000001];

    private static class Quotient {
        private final int P, Q;

        Quotient(int P, int Q) {
            this.P = P;
            this.Q = inverse(Q);
        }

        public Quotient add(Quotient other) {
            return new Quotient(  (int)(((long)P*Q + (long)other.P*other.Q) % REM), 1);
        }

        public Quotient multiply(Quotient other) {
            return new Quotient((int)((long)P*Q%REM*other.P%REM*other.Q%REM), 1);
        }

        @Override
        public String toString() {
            return String.valueOf((long)P*Q % REM);
        }

        private static int inverse(int Q) {
            if (Q < inverse.length && inverse[Q] != null) {return inverse[Q];}
            int inv = pow(Q, REM-2);
            if (Q < inverse.length) {inverse[Q] = inv;}
            return inv;
        }

        private static int pow(int a, int b) {
            if (b==0) {return 1;}
            else if (b%2==1) {return (int)((long)pow(a,b-1) * a % REM);}
            else {
                int mid = pow(a,b/2);
                return (int)((long)mid*mid%REM);
            }
        }
    }

    private static Quotient f(int c1, int c2) {
        if (dp[c1][c2] != null) {
            return dp[c1][c2];
        }
        if (c1+c2>=k) {
            dp[c1][c2] = new Quotient(c1+c2, 1).add(new Quotient(pa, pb));
        } else {
            dp[c1][c2] = f(c1, c2+1).multiply(new Quotient(pa, pa+pb)).add(
                    f(c1+c2, c2).multiply(new Quotient(pb, pa+pb)));
        }
        return dp[c1][c2];
    }

    public static void main(String[] args) throws Exception {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));

        String[] line = in.readLine().split(" ");
        k = Integer.parseInt(line[0]);
        pa = Integer.parseInt(line[1]);
        pb = Integer.parseInt(line[2]);

        out.write(f(0, 1).toString() + "\n");
        out.close();
    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;
/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskD solver = new TaskD();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskD {
        public final Rational ONE = new Rational(1, 1);
        public final Rational ZERO = new Rational(0, 1);

        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int k = in.readInt();
            int pa = in.readInt();
            int pb = in.readInt();
            Rational probA = new Rational(pa, pa + pb);
            Rational probB = new Rational(pb, pa + pb);
            Rational[][] probAtState = new Rational[k + 1][2 * k]; // numA, ABPairAlready
            for (int row = 0; row < probAtState.length; row++) {
                for (int col = 0; col < probAtState[0].length; col++) {
                    probAtState[row][col] = ZERO;
                }
            }
            probAtState[1][0] = ONE;
            for (int numA = 1; numA < k; numA++) {
                for (int ABPairAlready = 0; ABPairAlready < k; ABPairAlready++) {
                    { // with chance pa / (pa + pb) we get an A here
                        probAtState[numA + 1][ABPairAlready] = probAtState[numA][ABPairAlready].multiply(probA);
                    }
                    { // with chance pb / (pa + pb) we get a B here
                        probAtState[numA][ABPairAlready + numA] = probAtState[numA][ABPairAlready + numA].add(probAtState[numA][ABPairAlready].multiply(probB));
                    }
                }
            }
            Rational res = ZERO;
            // Here we count num ABPairs where we have at least k AB pairs already
            for (int numA = 1; numA < probAtState.length; numA++) {
                for (int ABPairAlready = k; ABPairAlready < probAtState[0].length; ABPairAlready++) {
                    res = res.add(probAtState[numA][ABPairAlready].multiply(ABPairAlready));
                }
            }
            Rational expectMoreA = (probB.reverse()).subtractOne();
            for (int ABPairAlready = 0; ABPairAlready < k; ABPairAlready++) {
                // Now here we do not quite have the number of AB Pairs we need
                // but we have plenty of A already
                Rational nowA = expectMoreA.add(ABPairAlready).add(k);
                res = res.add(nowA.multiply(probAtState[k][ABPairAlready]));
            }
            out.printLine((long) res.numerator * IntegerUtils.reverse(res.denominator, MiscUtils.MOD7) % MiscUtils.MOD7);
        }

        public class Rational {
            int numerator;
            int denominator;

            public Rational(int numerator, int denominator) {
                int gcd = IntegerUtils.gcd(Math.abs(numerator), Math.abs(denominator));
                this.numerator = numerator / gcd;
                this.denominator = denominator / gcd;
                this.numerator %= MiscUtils.MOD7;
                this.denominator %= MiscUtils.MOD7;
            }

            public Rational add(Rational other) {
                return new Rational((int) (((long) numerator * other.denominator + (long) denominator * other.numerator) % MiscUtils.MOD7),
                        (int) ((long) denominator * other.denominator % MiscUtils.MOD7));
            }

            public Rational add(long other) {
                return new Rational((int) ((numerator + (long) denominator * other) % MiscUtils.MOD7), denominator);
            }

            public Rational reverse() {
                if (numerator == 0) {
                    throw new ArithmeticException();
                }
                return new Rational(denominator, numerator);
            }

            public Rational multiply(long number) {
                return new Rational((int) ((long) numerator * number % MiscUtils.MOD7), denominator);
            }

            public Rational subtractOne() {
                return new Rational((int) (((long) numerator - denominator + MiscUtils.MOD7) % MiscUtils.MOD7), denominator);
            }

            public Rational multiply(Rational other) {
                return new Rational((int) ((long) numerator * other.numerator % MiscUtils.MOD7), (int) ((long) other.denominator * denominator % MiscUtils.MOD7));
            }
        }
    }
    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

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

        public void printLine(long i) {
            writer.println(i);
        }
    }
    static class IntegerUtils {
        public static int gcd(int a, int b) {
            a = Math.abs(a);
            b = Math.abs(b);
            while (b != 0) {
                int temp = a % b;
                a = b;
                b = temp;
            }
            return a;
        }

        public static long power(long base, long exponent, long mod) {
            if (base >= mod) {
                base %= mod;
            }
            if (exponent == 0) {
                return 1 % mod;
            }
            long result = power(base, exponent >> 1, mod);
            result = result * result % mod;
            if ((exponent & 1) != 0) {
                result = result * base % mod;
            }
            return result;
        }

        public static long reverse(long number, long module) {
            return power(number, module - 2, module);
        }
    }
    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int readInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);
        }
    }
    static class MiscUtils {
        public static final int MOD7 = (int) (1e9 + 7);
    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;
/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskD solver = new TaskD();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskD {
        public final Rational ONE = new Rational(1, 1);
        public final Rational ZERO = new Rational(0, 1);

        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int k = in.readInt();
            int pa = in.readInt();
            int pb = in.readInt();
            Rational probA = new Rational(pa, pa + pb);
            Rational probB = new Rational(pb, pa + pb);
            Rational[][] probAtState = new Rational[k + 1][2 * k]; // numA, ABPairAlready
            for (int row = 0; row < probAtState.length; row++) {
                for (int col = 0; col < probAtState[0].length; col++) {
                    probAtState[row][col] = ZERO;
                }
            }
            probAtState[1][0] = ONE;
            for (int numA = 1; numA < k; numA++) {
                for (int ABPairAlready = 0; ABPairAlready < k; ABPairAlready++) {
                    { // with chance pa / (pa + pb) we get an A here
                        probAtState[numA + 1][ABPairAlready] = probAtState[numA + 1][ABPairAlready].add(probAtState[numA][ABPairAlready].multiply(probA));
                    }
                    { // with chance pb / (pa + pb) we get a B here
                        probAtState[numA][ABPairAlready + numA] = probAtState[numA][ABPairAlready + numA].add(probAtState[numA][ABPairAlready].multiply(probB));
                    }
                }
            }
            Rational res = ZERO;
            // Here we count num ABPairs where we have at least k AB pairs already
            for (int numA = 1; numA < probAtState.length; numA++) {
                for (int ABPairAlready = k; ABPairAlready < probAtState[0].length; ABPairAlready++) {
                    res = res.add(probAtState[numA][ABPairAlready].multiply(ABPairAlready));
                }
            }
            Rational expectMoreA = (probB.reverse()).subtract(ONE);
            for (int ABPairAlready = 0; ABPairAlready < k; ABPairAlready++) {
                // Now here we do not quite have the number of AB Pairs we need
                // but we have plenty of A already
                Rational nowA = new Rational(k, 1).add(expectMoreA).add(new Rational(ABPairAlready, 1));
                Rational moar = nowA.multiply(probAtState[k][ABPairAlready]);
                res = res.add(moar);
            }
            out.printLine((long) res.numerator * IntegerUtils.reverse(res.denominator, MiscUtils.MOD7) % MiscUtils.MOD7);
        }

        public class Rational {
            int numerator;
            int denominator;

            public Rational(int numerator, int denominator) {
                if (denominator == 0) {
                    throw new IllegalArgumentException();
                }
                int gcd = IntegerUtils.gcd(Math.abs(numerator), Math.abs(denominator));
                if (denominator > 0) {
                    this.numerator = numerator / gcd;
                    this.denominator = denominator / gcd;
                } else {
                    this.numerator = -numerator / gcd;
                    this.denominator = -denominator / gcd;
                }
                this.numerator %= MiscUtils.MOD7;
                this.denominator %= MiscUtils.MOD7;
            }

            public String toString() {
                return numerator + "/" + denominator;
            }

            public Rational add(Rational other) {
                return new Rational((int) (((long) numerator * other.denominator + (long) denominator * other.numerator) % MiscUtils.MOD7),
                        (int) (((long) denominator * other.denominator) % MiscUtils.MOD7));
            }

            public Rational reverse() {
                if (numerator == 0) {
                    throw new ArithmeticException();
                }
                return new Rational(denominator, numerator);
            }

            public Rational subtract(Rational other) {
                return new Rational(numerator * other.denominator - denominator * other.numerator,
                        denominator * other.denominator);
            }

            public Rational multiply(Rational other) {
                return new Rational((int) ((long) numerator * other.numerator % MiscUtils.MOD7), (int) ((long) other.denominator * denominator % MiscUtils.MOD7));
            }

            public Rational multiply(int number) {
                return new Rational((int) ((long) numerator * number % MiscUtils.MOD7), denominator);
            }
        }
    }
    static class MiscUtils {
        public static final int MOD7 = (int) (1e9 + 7);
    }
    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

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

        public void printLine(long i) {
            writer.println(i);
        }
    }
    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int readInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);
        }
    }
    static class IntegerUtils {
        public static int gcd(int a, int b) {
            a = Math.abs(a);
            b = Math.abs(b);
            while (b != 0) {
                int temp = a % b;
                a = b;
                b = temp;
            }
            return a;
        }

        public static long power(long base, long exponent, long mod) {
            if (base >= mod) {
                base %= mod;
            }
            if (exponent == 0) {
                return 1 % mod;
            }
            long result = power(base, exponent >> 1, mod);
            result = result * result % mod;
            if ((exponent & 1) != 0) {
                result = result * base % mod;
            }
            return result;
        }

        public static long reverse(long number, long module) {
            return power(number, module - 2, module);
        }
    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;
/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskD solver = new TaskD();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskD {
        int create(int a, int b) {
            return (int) (((long) a * IntegerUtils.reverse(b, MiscUtils.MOD7)) % MiscUtils.MOD7);
        }

        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int k = in.readInt();
            int pa = in.readInt();
            int pb = in.readInt();
            int probA = create(pa, pa + pb);
            int probB = create(pb, pa + pb);
            int[][] probAtState = new int[k + 1][2 * k];
            probAtState[1][0] = 1;
            for (int numA = 1; numA < k; numA++) {
                for (int ABPairAlready = 0; ABPairAlready < k; ABPairAlready++) {
                    { // with chance pa / (pa + pb) we get an A here
                        probAtState[numA + 1][ABPairAlready] = (int) ((long) probAtState[numA][ABPairAlready] * probA % MiscUtils.MOD7);
                    }
                    { // with chance pb / (pa + pb) we get a B here
                        probAtState[numA][ABPairAlready + numA] = (probAtState[numA][ABPairAlready + numA] + (int) ((long) probAtState[numA][ABPairAlready] * probB % MiscUtils.MOD7)) % MiscUtils.MOD7;
                    }
                }
            }
            int res = 0;
            // Here we count num ABPairs where we have at least k AB pairs already
            for (int numA = 1; numA < probAtState.length; numA++) {
                for (int ABPairAlready = k; ABPairAlready < probAtState[0].length; ABPairAlready++) {
                    res = (res + (int) ((long) probAtState[numA][ABPairAlready] * ABPairAlready % MiscUtils.MOD7)) % MiscUtils.MOD7;
                }
            }
            int expectMoreA = create(pa, pb);
            for (int ABPairAlready = 0; ABPairAlready < k; ABPairAlready++) {
                // Now here we do not quite have the number of AB Pairs we need
                // but we have plenty of A already
                int nowA = (int) (((long) expectMoreA + ABPairAlready + k) % MiscUtils.MOD7);
                res = (res + (int) ((long) nowA * probAtState[k][ABPairAlready] % MiscUtils.MOD7)) % MiscUtils.MOD7;
            }
            out.printLine(res);
        }
    }
    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

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

        public void printLine(int i) {
            writer.println(i);
        }
    }
    static class IntegerUtils {
        public static long power(long base, long exponent, long mod) {
            if (base >= mod) {
                base %= mod;
            }
            if (exponent == 0) {
                return 1 % mod;
            }
            long result = power(base, exponent >> 1, mod);
            result = result * result % mod;
            if ((exponent & 1) != 0) {
                result = result * base % mod;
            }
            return result;
        }

        public static long reverse(long number, long module) {
            return power(number, module - 2, module);
        }
    }
    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int readInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);
        }
    }
    static class MiscUtils {
        public static final int MOD7 = (int) (1e9 + 7);
    }
}

import java.io.* ;
import java.util.* ;
import java.text.* ;
import java.math.* ;
import static java.lang.Math.min ;
import static java.lang.Math.max ;
import static java.lang.Math.sqrt ;
public class Codeshefcode{
	public static void main(String[] args) throws IOException{
		// Solver Machine = new Solver() ;
		// Machine.Solve() ;
		// Machine.Finish() ;
		new Thread(null,new Runnable(){
			public void run(){
				Solver Machine = new Solver() ;
				try{
					Machine.Solve() ;
					Machine.Finish() ;
				}catch(Exception e){
					e.printStackTrace() ;
					System.out.flush() ;
					System.exit(-1) ;
				}catch(Error e){
					e.printStackTrace() ;
					System.out.flush() ;
					System.exit(-1) ;
				}
			}
		},"Solver",1l<<27).start() ;
	}
}
class Mod{
	static long mod=1000000007 ;
	static long d(long a,long b){ return (a*MI(b))%mod ; }
	static long m(long a,long b){ return (a*b)%mod ; }
	static private long MI(long a){ return pow(a,mod-2) ; }
	static long pow(long a,long b){
		if(b<0) return pow(MI(a),-b) ;
		long val=a ; long ans=1 ;
		while(b!=0){
			if((b&1)==1) ans = (ans*val)%mod ;
			val = (val*val)%mod ;
			b/=2 ;
		}
		return ans ;
	}
}
class pair implements Comparable<pair>{
	long x ; long y ;
	pair(long x,long y){ this.x=x ; this.y=y ;}
	public int compareTo(pair p){
		return (this.x<p.x ? -1 : (this.x>p.x ? 1 : (this.y<p.y ? -1 : (this.y>p.y ? 1 : 0)))) ;
	}
}
class Solver{
	Reader ip = new Reader(System.in) ;
	PrintWriter op = new PrintWriter(System.out) ;
	pair dp[][] ;
	int k ;
	long pa,pb ;
	pair Pa,Pb ;
	public void Solve() throws IOException{
		k = ip.i() ;
		pa = ip.l() ;
		pb = ip.l() ;
		Pa = new pair(pa,pa+pb) ;
		Pb = new pair(pb,pa+pb) ;
		dp = new pair[k+1][k+1] ;
		for(int i=0 ; i<=k ; i++)
			for(int j=0 ; j<=k ; j++)
				if((i+j)>=k)
					dp[i][j] = init(i,j) ;
		pair res = Solve(1,0) ;
		pln(Mod.d(res.x,res.y)) ;
	}
	pair Solve(int i,int j){
		if(dp[i][j]!=null) return dp[i][j] ;
		pair p = add(mul(Pa,Solve(i+1,j)),mul(Pb,Solve(i,i+j))) ;
		dp[i][j] = p ;
		return dp[i][j] ;
	}
	pair init(long i,long j){
		return add(new pair(pa,pb),new pair(i+j,1)) ;
	}
	pair mul(pair a,pair b){
		return new pair(Mod.m(a.x,b.x),Mod.m(a.y,b.y)) ;
	}
	pair add(pair a,pair b){
		return new pair((Mod.m(a.x,b.y)+Mod.m(a.y,b.x))%Mod.mod,Mod.m(a.y,b.y)) ;
	}
	void Finish(){
		op.flush();
		op.close();
	}
	void p(Object o){
		op.print(o) ;
	}
	void pln(Object o){
		op.println(o) ;
	}
}
class mylist extends ArrayList<Integer>{}
class myset extends TreeSet<Integer>{}
class mystack extends Stack<Integer>{}
class mymap extends TreeMap<Long,Integer>{}
class Reader{
	BufferedReader reader;
	StringTokenizer tokenizer;
	Reader(InputStream input) {
		reader = new BufferedReader(
					new InputStreamReader(input) );
		tokenizer = new StringTokenizer("") ;
	}
	String s() throws IOException {
		while (!tokenizer.hasMoreTokens()){
			tokenizer = new StringTokenizer(
			reader.readLine()) ;
		}
		return tokenizer.nextToken();
	}
	int i() throws IOException {
		return Integer.parseInt(s()) ;
	}
	long l() throws IOException{
		return Long.parseLong(s()) ;
	}
	double d() throws IOException {
		return Double.parseDouble(s()) ;
	}
}

import com.sun.org.apache.regexp.internal.RE;

import java.io.*;
import java.nio.file.ClosedWatchServiceException;
import java.nio.file.OpenOption;
import java.security.SecureRandom;
import java.util.*;

public class Main {
    public static void main(String[] args) throws FileNotFoundException {
        ConsoleIO io = new ConsoleIO(new InputStreamReader(System.in), new PrintWriter(System.out));
        //String test = "C-large";
        //ConsoleIO io = new ConsoleIO(new FileReader("D:\\Dropbox\\code\\practice\\jb\\src\\" + test + ".in"), new PrintWriter(new File("D:\\Dropbox\\code\\practice\\jb\\src\\" + test + "-out.txt")));

       new Main(io).solve();

        io.close();
    }

    ConsoleIO io;
    Main(ConsoleIO io) {
        this.io = io;
    }

    List<List<Integer>> gr = new ArrayList<>();
    long MOD = 1_000_000_007;

    public void solve() {
        int k = io.ri();
        long pa = io.ri(), pb = io.ri();
        long pp = pa + pb;
        long rdb = div(pp, pb, MOD);
        long[][] res = new long[k+1][k+k+1];
        for(int i = 0;i<=k+k;i++)
            res[k][i] = (rdb - 1 + k + i + MOD) % MOD;
        for(int i = k-1;i>0;i--) {
            long[] row = res[i];
            for (int j = k + k; j >= 0; j--){
                if(j>=k) row[j] = j;
                else{
                    row[j] = div((res[i+1][j] * pa + res[i][i+j] * pb) % MOD, pp, MOD);
                }
            }
        }

        io.writeLine(res[1][0] + "");
    }

    long div(long a, long b, long mod) {
        return (a * pow(b, mod - 2, mod)) % mod;
    }

    long pow(long a, long p, long mod) {
        long res = 1;
        while (p > 0) {
            if (p % 2 == 1) res = (res * a) % mod;
            a = (a * a) % mod;
            p /= 2;
        }
        return res;
    }

}

class ConsoleIO {

    BufferedReader br;
    PrintWriter out;
    public ConsoleIO(Reader reader, PrintWriter writer){br = new BufferedReader(reader);out = writer;}
    public void flush(){this.out.flush();}
    public void close(){this.out.close();}
    public void writeLine(String s) {this.out.println(s);}
    public void writeInt(int a) {this.out.print(a);this.out.print(' ');}
    public void writeWord(String s){
        this.out.print(s);
    }
    public void writeIntArray(int[] a, int k, String separator) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < k; i++) {
            if (i > 0) sb.append(separator);
            sb.append(a[i]);
        }
        this.writeLine(sb.toString());
    }
    public int read(char[] buf, int len){try {return br.read(buf,0,len);}catch (Exception ex){ return -1; }}
    public String readLine() {try {return br.readLine();}catch (Exception ex){ return "";}}
    public long[] readLongArray() {
        String[]n=this.readLine().trim().split("\\s+");long[]r=new long[n.length];
        for(int i=0;i<n.length;i++)r[i]=Long.parseLong(n[i]);
        return r;
    }
    public int[] readIntArray() {
        String[]n=this.readLine().trim().split("\\s+");int[]r=new int[n.length];
        for(int i=0;i<n.length;i++)r[i]=Integer.parseInt(n[i]);
        return r;
    }
    public int[] readIntArray(int n) {
        int[] res = new int[n];
        char[] all = this.readLine().toCharArray();
        int cur = 0;boolean have = false;
        int k = 0;
        boolean neg = false;
        for(int i = 0;i<all.length;i++){
            if(all[i]>='0' && all[i]<='9'){
                cur = cur*10+all[i]-'0';
                have = true;
            }else if(all[i]=='-') {
                neg = true;
            }
            else if(have){
                res[k++] = neg?-cur:cur;
                cur = 0;
                have = false;
                neg = false;
            }
        }
        if(have)res[k++] = neg?-cur:cur;
        return res;
    }
    public int ri() {
        try {
            int r = 0;
            boolean start = false;
            boolean neg = false;
            while (true) {
                int c = br.read();
                if (c >= '0' && c <= '9') {
                    r = r * 10 + c - '0';
                    start = true;
                } else if (!start && c == '-') {
                    start = true;
                    neg = true;
                } else if (start || c == -1) return neg ? -r : r;
            }
        } catch (Exception ex) {
            return -1;
        }
    }
    public long readLong() {
        try {
            long r = 0;
            boolean start = false;
            boolean neg = false;
            while (true) {
                int c = br.read();
                if (c >= '0' && c <= '9') {
                    r = r * 10 + c - '0';
                    start = true;
                } else if (!start && c == '-') {
                    start = true;
                    neg = true;
                } else if (start || c == -1) return neg ? -r : r;
            }
        } catch (Exception ex) {
            return -1;
        }
    }
    public String readWord() {
        try {
            boolean start = false;
            StringBuilder sb = new StringBuilder();
            while (true) {
                int c = br.read();
                if (c!= ' ' && c!= '\r' && c!='\n' && c!='\t') {
                    sb.append((char)c);
                    start = true;
                } else if (start || c == -1) return sb.toString();
            }
        } catch (Exception ex) {
            return "";
        }
    }
    public char readSymbol() {
        try {
            while (true) {
                int c = br.read();
                if (c != ' ' && c != '\r' && c != '\n' && c != '\t') {
                    return (char) c;
                }
            }
        } catch (Exception ex) {
            return 0;
        }
    }
    //public char readChar(){try {return (char)br.read();}catch (Exception ex){ return 0; }}
}
class Pair {
    public Pair(int a, int b) {this.a = a;this.b = b;}
    public int a;
    public int b;
}
class PairLL {
    public PairLL(long a, long b) {this.a = a;this.b = b;}
    public long a;
    public long b;
}
class Triple {
    public Triple(int a, int b, int c) {this.a = a;this.b = b;this.c = c;}
    public int a;
    public int b;
    public int c;
}

import java.util.Scanner;

public class D {

	static int k, pa, pb, p;

	static long pra, prb;

	static long [][] dp = new long[2001][2001];

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);

		k = in.nextInt();
		pa = in.nextInt();
		pb = in.nextInt();
		p = pa + pb;

		pra = ((long)(pa) * modPow(p,mod-2) )%mod;
		prb = ((long)(pb) * modPow(p,mod-2) )%mod;

		long a = solve(1,0);
		System.out.println(a);
	}

	static long solve(int i, int j) {
		if(j >= k) return j%mod;
		if(i + j >= k) {
//			double r = (1.0*pa)/p;
//
//			double pp = (1.0*pb)/p;

			long c = i+j;

			long oneMR = (1 - pra + mod)%mod;
			long left = (c * modPow(oneMR,mod-2))%mod;
			long rightNum = pra;
			long rightDen = (oneMR * oneMR)%mod;
			long right = (rightNum * modPow(rightDen,mod - 2))%mod  ;

			dp[i][j] = (prb * ( (left + right)%mod))%mod;

		//	dp[i][j] = prb* (  (c/(1-r)) + (r/((1-r)*(1-r)))  );

			return dp[i][j];
		}

		if( dp[i][j]!= 0) return dp[i][j];

		dp[i][j] = ((pra * solve(i+1,j))%mod    + (prb * solve(i,i+j))%mod)%mod ;
		return dp[i][j];
	}

	static int mod = 1000000007;

	static long modPow(long n, int p) {
		if(p == 0) return 1;
		if(p%2 == 1) return (n * modPow(n,p-1))%mod;
		long t = modPow(n,p/2);

		return (t*t)%mod;

	}
}

import java.util.*;
import java.io.*;
public class NewYearandArrangement {

    /************************ SOLUTION STARTS HERE ************************/

    static class MM {       // MM (Modular Math) class
        static final long mod = (long) (1e9) + 7; // Default
        static long sub(long a, long b) {return (a - b  + mod) % mod;}
        static long mul(long a, long b) {return ((a % mod) * (b % mod)) % mod;}
        static long add(long a, long b) {return (a + b) % mod;}
        static long div(long a, long b) {return mul(a, modInverse(b));}
        static long modInverse(long n)  {return modPow(n, mod - 2);} // Fermat's little theorem
        static long modPow(long a , long b) {
            long pow = 1;
            while(b > 0) {
                if((b & 1L) == 1)
                    pow = ((pow * a) % mod);

                a = ((a * a) % (mod));
                b >>= 1;
            }
            return pow;
        }
    }

    static int k;
    static long pa , pb;
    static long probA , probB;
    static long memo[][];
    static long rec(int aCnt , int abCnt) {
        if(aCnt + abCnt >= k)
            return MM.add(aCnt + abCnt, MM.div(pa, pb));
        else if(memo[aCnt][abCnt] >= 0)
            return memo[aCnt][abCnt];
        else
            return memo[aCnt][abCnt] = MM.add(MM.mul(probA, rec(aCnt + 1, abCnt)),
                                              MM.mul(probB, rec(aCnt, abCnt + aCnt)));

    }

    private static void solve() {

        k = nextInt();
        pa = nextLong();
        pb = nextLong();
        probA = MM.div(pa, pa + pb);
        probB = MM.div(pb, pa + pb);

        memo = new long[k + 1][k + 1];
        for(long t[] : memo) Arrays.fill(t, -1);

        println(rec(1, 0)); // dp[1][0] = dp[0][0] this is because adding inf b's in start reduces to not adding

    }

    /************************ SOLUTION ENDS HERE ************************/

    /************************ TEMPLATE STARTS HERE **********************/

    public static void main(String[] args) throws IOException {
        reader = new BufferedReader(new InputStreamReader(System.in));
        writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)), false);
        st     = null;
        solve();
        reader.close();
        writer.close();
    }

    static BufferedReader reader;
    static PrintWriter    writer;
    static StringTokenizer st;

    static String next()
    {while(st == null || !st.hasMoreTokens()){try{String line = reader.readLine();if(line == null){return null;}
    st = new StringTokenizer(line);}catch (Exception e){throw new RuntimeException();}}return st.nextToken();}
    static String nextLine()  {String s=null;try{s=reader.readLine();}catch(IOException e){e.printStackTrace();}return s;}
    static int    nextInt()   {return Integer.parseInt(next());}
    static long   nextLong()  {return Long.parseLong(next());}
    static double nextDouble(){return Double.parseDouble(next());}
    static char   nextChar()  {return next().charAt(0);}
    static int[]  nextIntArray(int n)         {int[] a= new int[n];   int i=0;while(i<n){a[i++]=nextInt();}  return a;}
    static long[] nextLongArray(int n)        {long[]a= new long[n];  int i=0;while(i<n){a[i++]=nextLong();} return a;}
    static int[]  nextIntArrayOneBased(int n) {int[] a= new int[n+1]; int i=1;while(i<=n){a[i++]=nextInt();} return a;}
    static long[] nextLongArrayOneBased(int n){long[]a= new long[n+1];int i=1;while(i<=n){a[i++]=nextLong();}return a;}
    static void   print(Object o)  { writer.print(o);  }
    static void   println(Object o){ writer.println(o);}

    /************************ TEMPLATE ENDS HERE ************************/

}

/*****Author: Satyajeet Singh, Delhi Technological University************************************/
    import java.io.*;
    import java.util.*;
    import java.text.*;
    import java.lang.*;
    import java.math.*;
public class Main{
/*********************************************Constants******************************************/
    static PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static long mod=(long)1e9+7;
    static long mod1=998244353;
    static boolean sieve[];
    static ArrayList<Integer> primes;
    static long factorial[],invFactorial[];
    static ArrayList<Integer> graph[];
    static int pptr=0;
    static String st[];
/****************************************Solutions Begins***************************************/
    static int c;
    static long a,b,pa,pb,dp[][],ab;
    static long dfs(int i,int j){
        if(i>j)
            return (i+ab)%mod;
        if(dp[i][j]!=-1)
            return dp[i][j];
        long ans=(((i+dfs(i,j-i))%mod)*pb)%mod;
        ans+=(dfs(i+1,j)*pa)%mod;
        ans%=mod;
        return dp[i][j]=ans;
    }
    public static void main(String args[]) throws Exception{
        nl();
        c=pi();
        a=pi();
        b=pi();
        pa=(a*modulo(a+b,mod-2,mod))%mod;
        pb=(b*modulo(a+b,mod-2,mod))%mod;
        ab=(a*modulo(b,mod-2,mod))%mod;
        dp=new long[c+1][c+1];
        for(long arr[]:dp)
            Arrays.fill(arr,-1);
        long ans=dfs(1,c-1);
        out.println(ans);
/****************************************Solutions Ends**************************************************/
        out.flush();
        out.close();
    }
/****************************************Template Begins************************************************/
    static void nl() throws Exception{
        pptr=0;
        st=br.readLine().split(" ");
    }
    static void nls() throws Exception{
        pptr=0;
        st=br.readLine().split("");
    }
    static int pi(){
        return Integer.parseInt(st[pptr++]);
    }
    static long pl(){
        return Long.parseLong(st[pptr++]);
    }
    static double pd(){
        return Double.parseDouble(st[pptr++]);
    }
    static String ps(){
        return st[pptr++];
    }
/***************************************Precision Printing**********************************************/
    static void printPrecision(double d){
        DecimalFormat ft = new DecimalFormat("0.000000000000");
        out.print(ft.format(d));
    }
/**************************************Bit Manipulation**************************************************/
    static void printMask(long mask){
        System.out.println(Long.toBinaryString(mask));
    }
    static int countBit(long mask){
        int ans=0;
        while(mask!=0){
            mask&=(mask-1);
            ans++;
        }
        return ans;
    }
/******************************************Graph*********************************************************/
    static void Makegraph(int n){
        graph=new ArrayList[n];
        for(int i=0;i<n;i++){
            graph[i]=new ArrayList<>();
        }
    }
    static void addEdge(int a,int b){
        graph[a].add(b);
    }
    // static void addEdge(int a,int b,int c){
    //     graph[a].add(new Pair(b,c));
    // }
/*********************************************PAIR********************************************************/
    static class Pair implements Comparable<Pair> {
        int u;
        int v;
        int index=-1;
        public Pair(int u, int v) {
            this.u = u;
            this.v = v;
        }
        public int hashCode() {
            int hu = (int) (u ^ (u >>> 32));
            int hv = (int) (v ^ (v >>> 32));
            return 31 * hu + hv;
        }
        public boolean equals(Object o) {
            Pair other = (Pair) o;
            return u == other.u && v == other.v;
        }
        public int compareTo(Pair other) {
            if(index!=other.index)
                return Long.compare(index, other.index);
            return Long.compare(v, other.v)!=0?Long.compare(v, other.v):Long.compare(u, other.u);
        }
        public String toString() {
            return "[u=" + u + ", v=" + v + "]";
        }
    }
/******************************************Long Pair*******************************************************/
    static class Pairl implements Comparable<Pairl> {
            long u;
            long v;
            int index=-1;
            public Pairl(long u, long v) {
                this.u = u;
                this.v = v;
            }
            public int hashCode() {
                int hu = (int) (u ^ (u >>> 32));
                int hv = (int) (v ^ (v >>> 32));
                return 31 * hu + hv;
            }
            public boolean equals(Object o) {
                Pairl other = (Pairl) o;
                return u == other.u && v == other.v;
            }
            public int compareTo(Pairl other) {
                if(index!=other.index)
                    return Long.compare(index, other.index);
                return Long.compare(v, other.v)!=0?Long.compare(v, other.v):Long.compare(u, other.u);
            }
            public String toString() {
                return "[u=" + u + ", v=" + v + "]";
            }
        }
/*****************************************DEBUG***********************************************************/
    public static void debug(Object... o){
        System.out.println(Arrays.deepToString(o));
    }
/************************************MODULAR EXPONENTIATION***********************************************/
    static long modulo(long a,long b,long c){
        long x=1;
        long y=a%c;
        while(b > 0){
            if(b%2 == 1){
                x=(x*y)%c;
            }
            y = (y*y)%c; // squaring the base
            b /= 2;
        }
        return  x%c;
    }
/********************************************GCD**********************************************************/
    static long gcd(long x, long y){
        if(x==0)
            return y;
        if(y==0)
            return x;
        long r=0, a, b;
        a = (x > y) ? x : y; // a is greater number
        b = (x < y) ? x : y; // b is smaller number
        r = b;
        while(a % b != 0){
            r = a % b;
            a = b;
            b = r;
        }
        return r;
    }
/******************************************SIEVE**********************************************************/
    static void sieveMake(int n){
        sieve=new boolean[n];
        Arrays.fill(sieve,true);
        sieve[0]=false;
        sieve[1]=false;
        for(int i=2;i*i<n;i++){
            if(sieve[i]){
                for(int j=i*i;j<n;j+=i){
                    sieve[j]=false;
                }
            }
        }
        primes=new ArrayList<Integer>();
        for(int i=0;i<n;i++){
            if(sieve[i]){
                primes.add(i);
            }
        }
    }
/********************************************End***********************************************************/
}

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

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		FastScanner in = new FastScanner(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskD solver = new TaskD();
		solver.solve(1, in, out);
		out.close();
	}

	static class TaskD {
		int k;
		long pa;
		long pb;
		boolean[][] was;
		long[][] dp;
		final int MOD = (int) (1e9 + 7);

		public void solve(int testNumber, FastScanner in, PrintWriter out) {
			k = in.nextInt();
			pa = in.nextInt();
			pb = in.nextInt();
			long sum = pa + pb;
			pa = (int) (pa * inv(sum) % MOD);
			pb = (int) (pb * inv(sum) % MOD);
			// state is <number of "a", number of "ab" subseq.>
			was = new boolean[k + 1][k + 1];
			dp = new long[k + 1][k + 1];
			out.println(e(1, 0));
		}

		private long e(int i, int j) {
			if (j >= k) {
				return 0;
			}
			if (i >= k) {
				// 1) pb * i + pb * pa * (i + 1) + pb * pa^2 * (i + 2) + ...
				// 2) pa + pb = 1
				return (i + pa * inv(pb)) % MOD;
			}
			if (was[i][j]) {
				return dp[i][j];
			}
			long res = 0;
			res = (res + pa * e(i + 1, j)) % MOD;
			res = (res + pb * (i + e(i, i + j))) % MOD;
			was[i][j] = true;
			dp[i][j] = res;
			return res;
		}

		private long inv(long x) {
			return pow(x, MOD - 2);
		}

		private long pow(long a, long n) {
			long r = 1;
			while (n > 0) {
				if (n % 2 == 1) {
					r = r * a % MOD;
				}
				a = a * a % MOD;
				n /= 2;
			}
			return r;
		}

	}

	static class FastScanner {
		private BufferedReader in;
		private StringTokenizer st;

		public FastScanner(InputStream stream) {
			in = new BufferedReader(new InputStreamReader(stream));
		}

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

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

	}
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author prakharjain
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        _908D solver = new _908D();
        solver.solve(1, in, out);
        out.close();
    }

    static class _908D {
        int k;
        long pa;
        long pb;
        long[][] dp;
        int mod = (int) 1e9 + 7;
        long p1;
        long p2;
        long pab;
        long pbi;
        long pai;

        public void solve(int testNumber, InputReader in, OutputWriter out) {
            k = in.nextInt();
            pa = in.nextInt();
            pb = in.nextInt();

            dp = new long[2 * k][k + 1];

            for (int i = 0; i < 2 * k; i++) {
                for (int j = 0; j <= k; j++) {
                    dp[i][j] = -1;
                }
            }

            pab = pow(pa + pb, mod - 2, mod);
            p1 = pa * pab;
            p1 %= mod;
            p2 = pb * pab;
            p2 %= mod;

            pbi = pow(pb, mod - 2, mod);
            pai = pow(pa, mod - 2, mod);

            long ansa = p1 * rec(0, 1);
            ansa %= mod;

            ansa *= (pa + pb);
            ansa %= mod;
            ansa *= pai;

            out.print(ansa % mod);
        }

        long rec(int ck, int ca) {
            if (ck >= k) {
                return ck;
            }
            if (dp[ck][ca] != -1) {
                return dp[ck][ca];
            }

            dp[ck][ca] = 0;

            //Put b
            if (ca < k) {
                dp[ck][ca] += p2 * rec(ck + ca, ca);
                dp[ck][ca] %= mod;
            }

            //Put a
            if (ca < k) {
                dp[ck][ca] += p1 * rec(ck, ca + 1);
                dp[ck][ca] %= mod;
            } else {
                //dp[ck][ca] = (((p2 * (pa + pb)) % mod) * pbi);
                long t1 = 0, t2 = 0;
                t1 = p2 * (ck + ca);
                t1 %= mod;
                t1 *= (pa + pb);
                t1 %= mod;
                t1 *= pbi;
                t1 %= mod;

                t2 = p2;
                t2 %= mod;
                t2 *= p1;
                t2 %= mod;
                t2 *= (pa + pb);
                t2 %= mod;
                t2 *= pbi;
                t2 %= mod;
                t2 *= (pa + pb);
                t2 %= mod;
                t2 *= pbi;
                t2 %= mod;

                dp[ck][ca] += t1 + t2;
                dp[ck][ca] %= mod;
            }

            dp[ck][ca] %= mod;
            return dp[ck][ca];
        }

        long pow(long a, long p, int mod) {
            if (p == 0) {
                return 1;
            }

            long t = pow(a, p / 2, mod);

            if (p % 2 != 0) {
                return (((t * t) % mod) * a) % mod;
            } else {
                return (t * t) % mod;
            }
        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

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

        public void print(long i) {
            writer.print(i);
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int nextInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }
}

//package goodbye2017;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.InputMismatchException;

public class D {
	InputStream is;
	PrintWriter out;
	String INPUT = "";

	void solve()
	{
		int K = ni();
		long a = ni(), b = ni();
		int mod = 1000000007;
		long[][] dp = new long[K][K+1];
		dp[0][1] = 1;
		long pa = a * invl(a+b, mod) % mod;
		long pb = b * invl(a+b, mod) % mod;

		long x1 = pa * invl(pb, mod) % mod;
		long ans = 0;
		for(int i = 0;i < K;i++){
			for(int j = 1;j < K+1;j++){
				if(j+1 < K+1){
					dp[i][j+1] += dp[i][j] * pa;
					dp[i][j+1] %= mod;
				}else{
					// #ab+#a+pa/pb
					ans += dp[i][j] * pa % mod * (i+j+1+x1);
					ans %= mod;
				}
				if(i+j < K){
					dp[i+j][j] += dp[i][j] * pb;
					dp[i+j][j] %= mod;
				}else{
					ans += dp[i][j] * pb % mod * (i+j);
					ans %= mod;
				}
			}
		}
		out.println(ans);
	}

	public static long invl(long a, long mod) {
		long b = mod;
		long p = 1, q = 0;
		while (b > 0) {
			long c = a / b;
			long d;
			d = a;
			a = b;
			b = d % b;
			d = p;
			p = q;
			q = d - c * q;
		}
		return p < 0 ? p + mod : p;
	}

	void run() throws Exception
	{
		is = oj ? System.in : new ByteArrayInputStream(INPUT.getBytes());
		out = new PrintWriter(System.out);

		long s = System.currentTimeMillis();
		solve();
		out.flush();
		tr(System.currentTimeMillis()-s+"ms");
	}

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

	private byte[] inbuf = new byte[1024];
	public int lenbuf = 0, ptrbuf = 0;

	private int readByte()
	{
		if(lenbuf == -1)throw new InputMismatchException();
		if(ptrbuf >= lenbuf){
			ptrbuf = 0;
			try { lenbuf = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }
			if(lenbuf <= 0)return -1;
		}
		return inbuf[ptrbuf++];
	}

	private boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }
	private int skip() { int b; while((b = readByte()) != -1 && isSpaceChar(b)); return b; }

	private double nd() { return Double.parseDouble(ns()); }
	private char nc() { return (char)skip(); }

	private String ns()
	{
		int b = skip();
		StringBuilder sb = new StringBuilder();
		while(!(isSpaceChar(b))){ // when nextLine, (isSpaceChar(b) && b != ' ')
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}

	private char[] ns(int n)
	{
		char[] buf = new char[n];
		int b = skip(), p = 0;
		while(p < n && !(isSpaceChar(b))){
			buf[p++] = (char)b;
			b = readByte();
		}
		return n == p ? buf : Arrays.copyOf(buf, p);
	}

	private char[][] nm(int n, int m)
	{
		char[][] map = new char[n][];
		for(int i = 0;i < n;i++)map[i] = ns(m);
		return map;
	}

	private int[] na(int n)
	{
		int[] a = new int[n];
		for(int i = 0;i < n;i++)a[i] = ni();
		return a;
	}

	private int ni()
	{
		int num = 0, b;
		boolean minus = false;
		while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
		if(b == '-'){
			minus = true;
			b = readByte();
		}

		while(true){
			if(b >= '0' && b <= '9'){
				num = num * 10 + (b - '0');
			}else{
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	private long nl()
	{
		long num = 0;
		int b;
		boolean minus = false;
		while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
		if(b == '-'){
			minus = true;
			b = readByte();
		}

		while(true){
			if(b >= '0' && b <= '9'){
				num = num * 10 + (b - '0');
			}else{
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	private boolean oj = System.getProperty("ONLINE_JUDGE") != null;
	private void tr(Object... o) { if(!oj)System.out.println(Arrays.deepToString(o)); }
}

import java.io.*;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.util.*;

public class q5 {
	static int k,pa,pb;
	static long dp[][],mod=(long)1e9+7;

	static long modPow(long a, long b, long m) {
		long res=1;
		while(b>0) {
			if(b%2==1) res*=a;
			res%=m;
			a=a*a;
			a%=m;
			b/=2;
		}
		return res;
	}
	static long solve(int i, int j) {
		if(j>=k) return j;
		if(i+j>=k) {
			return ((i +j+ mod-1+ ((pa+pb)*modPow(pb,mod-2,mod))%mod))%mod;
		}
		if(dp[i][j]==-1) {
			dp[i][j]= (pa* solve(i+1,j))%mod +( pb*solve(i,i+j))%mod;
			dp[i][j]%=mod;
			dp[i][j]*=modPow(pa+pb,mod-2,mod);
			dp[i][j]%=mod;
		}
		return dp[i][j];
	}

	public static void main(String[] args) throws IOException {

		Reader.init(System.in);
		PrintWriter out=new PrintWriter(System.out);
		k=Reader.nextInt();pa=Reader.nextInt();pb=Reader.nextInt();
		dp=new long[k+1][k+1];
		for(int i=0;i<=k;i++) Arrays.fill(dp[i], -1);
		out.println(solve(1,0));
		out.flush();
	}
}

class Reader {
    static BufferedReader reader;
    static StringTokenizer tokenizer;
    /** call this method to initialize reader for InputStream */
    static void init() throws IOException {
    	 reader = new BufferedReader(
                 new FileReader("input.txt"));
    tokenizer = new StringTokenizer("");
    }
    static void init(InputStream input) {
        reader = new BufferedReader(
                     new InputStreamReader(input) );
        tokenizer = new StringTokenizer("");
    }
    /** get next word */
    static String nextLine() throws IOException{
    	return reader.readLine();
    }
    static String next() throws IOException {
        while ( ! tokenizer.hasMoreTokens() ) {
            //TODO add check for eof if necessary
            tokenizer = new StringTokenizer(
                   reader.readLine() );
        }
        return tokenizer.nextToken();
    }
    static int nextInt() throws IOException {
        return Integer.parseInt( next() );
    }
    static long nextLong() throws IOException {
        return Long.parseLong( next() );
    }
    static double nextDouble() throws IOException {
        return Double.parseDouble( next() );
    }
}

/*
If you want to aim high, aim high
Don't let that studying and grades consume you
Just live life young
******************************
If I'm the sun, you're the moon
Because when I go up, you go down
*******************************
I'm working for the day I will surpass you
https://www.a2oj.com/Ladder16.html
*/
import java.util.*;
import java.io.*;
import java.math.*;

   public class D3
   {
      static long MOD = 1000000007L;
      static long pA;
      static long pB;
      static long denom;
      static long cancer;
      public static void main(String omkar[]) throws Exception
      {
         BufferedReader infile = new BufferedReader(new InputStreamReader(System.in));
         StringTokenizer st = new StringTokenizer(infile.readLine());
         int K = Integer.parseInt(st.nextToken());
         long pa = Long.parseLong(st.nextToken());
         long pb = Long.parseLong(st.nextToken());
         //brain tumor
         denom = power(pa+pb, MOD-2, MOD);
         cancer = (pa+pb)*power(pb,MOD-2,MOD);
         cancer %= MOD;
         pA = pa;
         pB = pb;
         dp = new long[K+1][K+1];
         for(int i=0; i <= K; i++)
            Arrays.fill(dp[i], -69);
         System.out.println(dfs(0,1));
      }
      static long[][] dp;
      public static long dfs(int k, int a)
      {
         int K = dp.length-1;
         //k = # of current 'ab'
         //a = # of current 'a'
         if(dp[k][a] != -69)
            return dp[k][a];
         if(k >= K)
            return dp[k][a] = k;
         else if(k+a >= K)
            return dp[k][a] = (k+a-1+cancer)%MOD;
         return dp[k][a] = denom*((pA*dfs(k,a+1)+pB*dfs(k+a,a))%MOD)%MOD;
      }
      public static long power(long x, long y, long p)
      {
          long res = 1L;
          x = x % p;
          while (y > 0)
          {
              if((y & 1)==1)
                  res = (res * x) % p;
              y = y >> 1;
              x = (x * x) % p;
          }
          return res;
      }
   }

import java.io.*;
import java.util.*;
import java.math.*;
import java.util.concurrent.*;

public final class arbitary_arrangement
{
    static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
	static FastScanner sc=new FastScanner(br);
    static PrintWriter out=new PrintWriter(System.out);
	static Random rnd=new Random();
	static long mod=(long)(1e9+7);
	static long[][] dp;
	static int maxn=(int)(1e3+3);
	static int k;
	static long pa,pb;

	static long solve(int a,int ab)
	{
		if(ab>=k)
		{
			return ab;
		}

		if(a>=k)
		{
			return calc(a,ab);
		}

		if(dp[a][ab]!=-1)
		{
			return dp[a][ab];
		}

		else
		{
			long val1=(pa*solve(a+1,ab))%mod,val2=(pb*solve(a,ab+a))%mod;

			dp[a][ab]=(val1+val2)%mod;

			return dp[a][ab];
		}
	}

	static long calc(int a,int ab)
	{
		long val1=((-1+mod)*pow(pa-1,mod-2))%mod;val1=(val1*(ab+a))%mod;

		long val2=((pa-1)*(pa-1))%mod;val2=pow(val2,mod-2)%mod;

		val2=(val2*pa)%mod;

		long ret=(val1+val2)%mod;

		return (pb*ret)%mod;
	}

	static long pow(long a,long b)
	{
		long x=1,y=a;

		while(b>0)
		{
			if(b%2==1)
			{
				x=(x*y)%mod;
			}

			y=(y*y)%mod;b=b/2;
		}

		return x;
	}

    public static void main(String args[]) throws Exception
    {
		k=sc.nextInt();pa=sc.nextInt();pb=sc.nextInt();

		long val1=(pa*pow(pa+pb,mod-2))%mod,val2=(pb*pow(pa+pb,mod-2))%mod;

		pa=val1;pb=val2;

		dp=new long[maxn][maxn];long mul=((-pa+mod)*pow(pb-1,mod-2))%mod;

		for(int i=0;i<maxn;i++)
		{
			for(int j=0;j<maxn;j++)
			{
				dp[i][j]=-1;
			}
		}

		long res=(mul*solve(1,0))%mod;

		out.println(res);out.close();
    }
}
class FastScanner
{
    BufferedReader in;
    StringTokenizer st;

    public FastScanner(BufferedReader in) {
        this.in = in;
    }

    public String nextToken() throws Exception {
        while (st == null || !st.hasMoreTokens()) {
            st = new StringTokenizer(in.readLine());
        }
        return st.nextToken();
    }

	public String next() throws Exception {
		return nextToken().toString();
	}

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

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

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

import java.io.*;
import java.util.*;

public class D {

	static final int P = 1_000_000_007;

	void submit() {
		int k = nextInt();
		int pa = nextInt();
		int pb = nextInt();

		int p = (int) ((long) pa * inv(pa + pb) % P);
		int q = (int) ((long) pb * inv(pa + pb) % P);

		int z = (int)((long)p * inv(q) % P);

		int[][] dp = new int[k + 1][k + 1];

		int ans = 0;

		dp[1][0] = 1;
		for (int x = 0; x <= k; x++) {
			for (int y = 0; y <= k; y++) {
				if (x + y >= k) {

					int ev = y + x + z;
					if (ev >= P) {
						ev -= P;
					}

					ans += (int)((long)dp[x][y] * ev % P);
					if (ans >= P) {
						ans -= P;
					}

					// think about it
					continue;
				}
				dp[x + 1][y] += (int) ((long) dp[x][y] * p % P);
				if (dp[x + 1][y] >= P) {
					dp[x + 1][y] -= P;
				}

				dp[x][x + y] += (int) ((long) dp[x][y] * q % P);
				if (dp[x][x + y] >= P) {
					dp[x][x + y] -= P;
				}
			}
		}
		out.println(ans);
	}

	int inv(int x) {
		return x == 1 ? 1 : P - (int) ((long) (P / x) * inv(P % x) % P);
	}

	void preCalc() {

	}

	void stress() {

	}

	void test() {

	}

	D() throws IOException {
		br = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);
		preCalc();
		submit();
		// stress();
		// test();
		out.close();
	}

	static final Random rng = new Random();

	static int rand(int l, int r) {
		return l + rng.nextInt(r - l + 1);
	}

	public static void main(String[] args) throws IOException {
		new D();
	}

	BufferedReader br;
	PrintWriter out;
	StringTokenizer st;

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

	String nextString() {
		try {
			return br.readLine();
		} catch (IOException e) {
			throw new RuntimeException(e);
		}
	}

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

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

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

/**
 * DA-IICT
 * Author : Savaliya Sagar
 */
import java.io.*;
import java.math.*;
import java.util.*;

public class D908
{
	int k, mod = (int) (1e9 + 7);
	long pa, pb, pa_pb;
	long dp[][];

	void solve()
	{
		k = ni();
		dp = new long[k + 5][k + 5];
		for (int i = 0; i < k + 5; i++)
		{
			Arrays.fill(dp[i], -1);
		}
		int a = ni();
		int b = ni();
		pa = mul(a, pow(a + b, mod - 2, mod));
		pb = mul(b, pow(a + b, mod - 2, mod));
		pa_pb = mul(a, pow(b, mod - 2, mod));
		out.println(rec(1, 0));
	}

	long rec(int a, int ab)
	{
		if (ab >= k)
			return ab;
		if (a >= k)
		{
			return (a + 0L + ab + pa_pb) % mod;
		}
		if (dp[a][ab] != -1)
			return dp[a][ab];
		dp[a][ab] = rec(a + 1, ab) * pa + 0L + rec(a, ab + a) * pb;
		dp[a][ab] %= mod;
		return (dp[a][ab]);
	}

	long add(long a, long b)
	{
		long sum = a + b;
		if (sum >= mod)
			sum -= mod;
		return sum;
	}

	long sub(long a, long b)
	{
		long sub = a - b;
		if (sub < 0)
			sub += mod;
		return sub;
	}

	long mul(long a, long b)
	{
		return (a * b) % mod;
	}

	long pow(long x, long n, long mod)
	{
		long res = 1;
		x %= mod;
		while (n > 0)
		{
			if (n % 2 == 1)
			{
				res = (res * x) % mod;
			}
			x = (x * x) % mod;
			n /= 2;
		}
		return res;
	}

	void run() throws Exception
	{
		out = new PrintWriter(System.out);
		reader = new BufferedReader(new InputStreamReader(System.in), 32768);
		tokenizer = null;
		solve();
		out.flush();
	}

	public int ni()
	{
		return Integer.parseInt(next());
	}

	BufferedReader reader;
	StringTokenizer tokenizer;
	PrintWriter out;

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

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

import java.awt.*;
import java.io.*;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.*;
import java.util.List;
import java.util.Queue;

import static java.lang.Math.max;
import static java.lang.Math.min;

public class D implements Runnable{

    // SOLUTION AT THE TOP OF CODE!!!
    // HACK ME PLEASE IF YOU CAN!!!
    // PLEASE!!!
    // PLEASE!!!
    // PLEASE!!!

    private final static boolean FIRST_INPUT_STRING = false;
    private final static boolean MULTIPLE_TESTS = true;
    private final boolean ONLINE_JUDGE = !new File("input.txt").exists();
//    private final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;

    private final static int MAX_STACK_SIZE = 128;

    private final static boolean OPTIMIZE_READ_NUMBERS = false;

    /////////////////////////////////////////////////////////////////////

    private final static Random rnd = new Random();
    private final static String fileName = "";

    private final static long MODULO = 1000 * 1000 * 1000 + 7;

    // THERE SOLUTION STARTS!!!
    private void solve() {
        int kMax = readInt();
        long paInt = readInt();
        long pbInt = readInt();

        long inverseSum = inverse(paInt + pbInt);

        long pa = mult(paInt, inverseSum);
        long pb = mult(pbInt, inverseSum);
//
//        double pa = paInt * 1.0 / (paInt + pbInt);
//        double pb = 1 - pa;

        long[][] dp = new long[kMax + kMax + 1][kMax + 1];
        dp[0][1] = 1;

        for (int sum = 1; sum < kMax; ++sum) {
            for (int k = 0; k <= sum; ++k) {
                int a = sum - k;
                // next a
                dp[k][a + 1] = add(dp[k][a + 1], mult(pa, dp[k][a]));

                // next b
                dp[k + a][a] = add(dp[k + a][a], mult(pb, dp[k][a]));
            }
        }

        long paDivpb = mult(pa, inverse(pb));

        long answer = 0;
        for (int k = 0; k < dp.length; ++k) {
            for (int a = 1; a < dp[k].length; ++a) {
                if (k + a < kMax) continue;

                long delta = mult(dp[k][a], add(k + a, paDivpb));
                answer = add(answer, delta);
            }
        }

        out.println(answer);
    }

    /////////////////////////////////////////////////////////////////////

    private static long add(long a, long b) { return (a + b) % MODULO; }
    private static long subtract(long a, long b) { return add(a, MODULO - b) % MODULO; }
    private static long mult(long a, long b) { return (a * b) % MODULO; }

    private static long inverse(long x) {
        return binpow(x, MODULO - 2);
    }

    private static long binpow(long base, long power) {
        if (power == 0) return 1;
        if ((power & 1) == 0) {
            long half = binpow(base, power >> 1);
            return mult(half, half);
        } else {
            return mult(binpow(base, power - 1), base);
        }
    }

    /////////////////////////////////////////////////////////////////////

    public void run(){
        try{
            timeInit();
            Locale.setDefault(Locale.US);

            init();

            if (ONLINE_JUDGE) {
                solve();
            } else {
                do {
                    try {
                        timeInit();
                        solve();
                        time();

                        out.println();
                        out.flush();
                    } catch (NumberFormatException e) {
                        break;
                    } catch (NullPointerException e) {
                        if (FIRST_INPUT_STRING) break;
                        else throw e;
                    }
                } while (MULTIPLE_TESTS);
            }

            out.close();
            time();
        }catch (Exception e){
            e.printStackTrace(System.err);
            System.exit(-1);
        }
    }

    /////////////////////////////////////////////////////////////////////

    private BufferedReader in;
    private OutputWriter out;
    private StringTokenizer tok = new StringTokenizer("");

    public static void main(String[] args){
        new Thread(null, new D(), "", MAX_STACK_SIZE * (1L << 20)).start();
    }

    /////////////////////////////////////////////////////////////////////

    private void init() throws FileNotFoundException{
        Locale.setDefault(Locale.US);

        if (ONLINE_JUDGE){
            if (fileName.isEmpty()) {
                in = new BufferedReader(new InputStreamReader(System.in));
                out = new OutputWriter(System.out);
            } else {
                in = new BufferedReader(new FileReader(fileName + ".in"));
                out = new OutputWriter(fileName + ".out");
            }
        }else{
            in = new BufferedReader(new FileReader("input.txt"));
            out = new OutputWriter("output.txt");
        }
    }

    ////////////////////////////////////////////////////////////////

    private long timeBegin;

    private void timeInit() {
        this.timeBegin = System.currentTimeMillis();
    }

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

    private void debug(Object... objects){
        if (ONLINE_JUDGE){
            for (Object o: objects){
                System.err.println(o.toString());
            }
        }
    }

    /////////////////////////////////////////////////////////////////////

    private String delim = " ";

    private String readLine() {
        try {
            return in.readLine();
        } catch (IOException e) {
            throw new RuntimeIOException(e);
        }
    }

    private String readString() {
        try {
            while(!tok.hasMoreTokens()){
                tok = new StringTokenizer(readLine(), delim);
            }

            return tok.nextToken(delim);
        } catch (NullPointerException e) {
            return null;
        }
    }

    /////////////////////////////////////////////////////////////////

    private final char NOT_A_SYMBOL = '\0';

    private char readChar() {
        try {
            int intValue = in.read();

            if (intValue == -1){
                return NOT_A_SYMBOL;
            }

            return (char) intValue;
        } catch (IOException e) {
            throw new RuntimeIOException(e);
        }
    }

    private char[] readCharArray() {
        return readLine().toCharArray();
    }

    private char[][] readCharField(int rowsCount) {
        char[][] field = new char[rowsCount][];
        for (int row = 0; row < rowsCount; ++row) {
            field[row] = readCharArray();
        }

        return field;
    }

    /////////////////////////////////////////////////////////////////

    private long optimizedReadLong() {
        int sign = 1;
        long result = 0;
        boolean started = false;
        while (true) {
            try {
                int j = in.read();
                if (-1 == j) {
                    if (started) return sign * result;
                    throw new NumberFormatException();
                }

                if (j == '-') {
                    if (started) throw new NumberFormatException();
                    sign = -sign;
                }

                if ('0' <= j && j <= '9') {
                    result = result * 10 + j - '0';
                    started = true;
                } else if (started) {
                    return sign * result;
                }
            } catch (IOException e) {
                throw new RuntimeIOException(e);
            }
        }
    }

    private int readInt() {

        if (!OPTIMIZE_READ_NUMBERS) {
            return Integer.parseInt(readString());
        } else {
            return (int) optimizedReadLong();
        }
    }

    private int[] readIntArray(int size) {
        int[] array = new int[size];

        for (int index = 0; index < size; ++index){
            array[index] = readInt();
        }

        return array;
    }

    private int[] readSortedIntArray(int size) {
        Integer[] array = new Integer[size];

        for (int index = 0; index < size; ++index) {
            array[index] = readInt();
        }
        Arrays.sort(array);

        int[] sortedArray = new int[size];
        for (int index = 0; index < size; ++index) {
            sortedArray[index] = array[index];
        }

        return sortedArray;
    }

    private int[] readIntArrayWithDecrease(int size) {
        int[] array = readIntArray(size);

        for (int i = 0; i < size; ++i) {
            array[i]--;
        }

        return array;
    }

    ///////////////////////////////////////////////////////////////////

    private int[][] readIntMatrix(int rowsCount, int columnsCount) {
        int[][] matrix = new int[rowsCount][];

        for (int rowIndex = 0; rowIndex < rowsCount; ++rowIndex) {
            matrix[rowIndex] = readIntArray(columnsCount);
        }

        return matrix;
    }

    private int[][] readIntMatrixWithDecrease(int rowsCount, int columnsCount) {
        int[][] matrix = new int[rowsCount][];

        for (int rowIndex = 0; rowIndex < rowsCount; ++rowIndex) {
            matrix[rowIndex] = readIntArrayWithDecrease(columnsCount);
        }

        return matrix;
    }

    ///////////////////////////////////////////////////////////////////

    private long readLong() {
        if (!OPTIMIZE_READ_NUMBERS) {
            return Long.parseLong(readString());
        } else {
            return optimizedReadLong();
        }
    }

    private long[] readLongArray(int size) {
        long[] array = new long[size];

        for (int index = 0; index < size; ++index){
            array[index] = readLong();
        }

        return array;
    }

    ////////////////////////////////////////////////////////////////////

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

    private double[] readDoubleArray(int size) {
        double[] array = new double[size];

        for (int index = 0; index < size; ++index){
            array[index] = readDouble();
        }

        return array;
    }

    ////////////////////////////////////////////////////////////////////

    private BigInteger readBigInteger() {
        return new BigInteger(readString());
    }

    private BigDecimal readBigDecimal() {
        return new BigDecimal(readString());
    }

    /////////////////////////////////////////////////////////////////////

    private Point readPoint() {
        int x = readInt();
        int y = readInt();
        return new Point(x, y);
    }

    private Point[] readPointArray(int size) {
        Point[] array = new Point[size];

        for (int index = 0; index < size; ++index){
            array[index] = readPoint();
        }

        return array;
    }

    /////////////////////////////////////////////////////////////////////

    @Deprecated
    private List<Integer>[] readGraph(int vertexNumber, int edgeNumber) {
        @SuppressWarnings("unchecked")
        List<Integer>[] graph = new List[vertexNumber];

        for (int index = 0; index < vertexNumber; ++index){
            graph[index] = new ArrayList<Integer>();
        }

        while (edgeNumber-- > 0){
            int from = readInt() - 1;
            int to = readInt() - 1;

            graph[from].add(to);
            graph[to].add(from);
        }

        return graph;
    }

    private static class GraphBuilder {

        final int size;
        final List<Integer>[] edges;

        static GraphBuilder createInstance(int size) {
            List<Integer>[] edges = new List[size];
            for (int v = 0; v < size; ++v) {
                edges[v] = new ArrayList<Integer>();
            }

            return new GraphBuilder(edges);
        }

        private GraphBuilder(List<Integer>[] edges) {
            this.size = edges.length;
            this.edges = edges;
        }

        public void addEdge(int from, int to) {
            addDirectedEdge(from, to);
            addDirectedEdge(to, from);
        }

        public void addDirectedEdge(int from, int to) {
            edges[from].add(to);
        }

        public int[][] build() {
            int[][] graph = new int[size][];
            for (int v = 0; v < size; ++v) {
                List<Integer> vEdges = edges[v];
                graph[v] = castInt(vEdges);
            }

            return graph;
        }
    }

    private final static int ZERO_INDEXATION = 0, ONE_INDEXATION = 1;

    private int[][] readUnweightedGraph(int vertexNumber, int edgesNumber) {
        return readUnweightedGraph(vertexNumber, edgesNumber, ONE_INDEXATION, false);
    }

    private int[][] readUnweightedGraph(int vertexNumber, int edgesNumber,
                                        int indexation, boolean directed
    ) {
        GraphBuilder graphBuilder = GraphBuilder.createInstance(vertexNumber);
        for (int i = 0; i < edgesNumber; ++i) {
            int from = readInt() - indexation;
            int to = readInt() - indexation;

            if (directed) graphBuilder.addDirectedEdge(from, to);
            else graphBuilder.addEdge(from, to);
        }

        return graphBuilder.build();
    }

    private static class Edge {
        int to;
        int w;

        Edge(int to, int w) {
            this.to = to;
            this.w = w;
        }
    }

    private Edge[][] readWeightedGraph(int vertexNumber, int edgesNumber) {
        return readWeightedGraph(vertexNumber, edgesNumber, ONE_INDEXATION, false);
    }

    private Edge[][] readWeightedGraph(int vertexNumber, int edgesNumber,
                                       int indexation, boolean directed) {
        @SuppressWarnings("unchecked")
        List<Edge>[] graph = new List[vertexNumber];
        for (int v = 0; v < vertexNumber; ++v) {
            graph[v] = new ArrayList<Edge>();
        }

        while (edgesNumber --> 0) {
            int from = readInt() - indexation;
            int to = readInt() - indexation;
            int w = readInt();

            graph[from].add(new Edge(to, w));
            if (!directed) graph[to].add(new Edge(from, w));
        }

        Edge[][] graphArrays = new Edge[vertexNumber][];
        for (int v = 0; v < vertexNumber; ++v) {
            graphArrays[v] = graph[v].toArray(new Edge[0]);
        }

        return graphArrays;
    }

    /////////////////////////////////////////////////////////////////////

    private static class IntIndexPair {

        static Comparator<IntIndexPair> increaseComparator = new Comparator<D.IntIndexPair>() {

            @Override
            public int compare(D.IntIndexPair indexPair1, D.IntIndexPair indexPair2) {
                int value1 = indexPair1.value;
                int value2 = indexPair2.value;

                if (value1 != value2) return value1 - value2;

                int index1 = indexPair1.index;
                int index2 = indexPair2.index;

                return index1 - index2;
            }
        };

        static Comparator<IntIndexPair> decreaseComparator = new Comparator<D.IntIndexPair>() {

            @Override
            public int compare(D.IntIndexPair indexPair1, D.IntIndexPair indexPair2) {
                int value1 = indexPair1.value;
                int value2 = indexPair2.value;

                if (value1 != value2) return -(value1 - value2);

                int index1 = indexPair1.index;
                int index2 = indexPair2.index;

                return index1 - index2;
            }
        };

        static IntIndexPair[] from(int[] array) {
            IntIndexPair[] iip = new IntIndexPair[array.length];
            for (int i = 0; i < array.length; ++i) {
                iip[i] = new IntIndexPair(array[i], i);
            }

            return iip;
        }

        int value, index;

        IntIndexPair(int value, int index) {
            super();
            this.value = value;
            this.index = index;
        }

        int getRealIndex() {
            return index + 1;
        }
    }

    private IntIndexPair[] readIntIndexArray(int size) {
        IntIndexPair[] array = new IntIndexPair[size];

        for (int index = 0; index < size; ++index) {
            array[index] = new IntIndexPair(readInt(), index);
        }

        return array;
    }

    /////////////////////////////////////////////////////////////////////

    private static class OutputWriter extends PrintWriter {

        final int DEFAULT_PRECISION = 12;

        private int precision;
        private String format, formatWithSpace;

        {
            precision = DEFAULT_PRECISION;

            format = createFormat(precision);
            formatWithSpace = format + " ";
        }

        OutputWriter(OutputStream out) {
            super(out);
        }

        OutputWriter(String fileName) throws FileNotFoundException {
            super(fileName);
        }

        int getPrecision() {
            return precision;
        }

        void setPrecision(int precision) {
            precision = max(0, precision);
            this.precision = precision;

            format = createFormat(precision);
            formatWithSpace = format + " ";
        }

        String createFormat(int precision){
            return "%." + precision + "f";
        }

        @Override
        public void print(double d){
            printf(format, d);
        }

        @Override
        public void println(double d){
            print(d);
            println();
        }

        void printWithSpace(double d){
            printf(formatWithSpace, d);
        }

        void printAll(double...d){
            for (int i = 0; i < d.length - 1; ++i){
                printWithSpace(d[i]);
            }

            print(d[d.length - 1]);
        }

        void printlnAll(double... d){
            printAll(d);
            println();
        }

        void printAll(int... array) {
        	for (int value : array) {
        		print(value + " ");
        	}
        }

        void printlnAll(int... array) {
        	printAll(array);
        	println();
        }

        void printAll(long... array) {
        	for (long value : array) {
        		print(value + " ");
        	}
        }

        void printlnAll(long... array) {
        	printAll(array);
        	println();
        }
    }

    /////////////////////////////////////////////////////////////////////

    private static class RuntimeIOException extends RuntimeException {

        /**
         *
         */
        private static final long serialVersionUID = -6463830523020118289L;

        RuntimeIOException(Throwable cause) {
            super(cause);
        }
    }

    /////////////////////////////////////////////////////////////////////
    //////////////// Some useful constants andTo functions ////////////////
    /////////////////////////////////////////////////////////////////////

    private static final int[][] steps = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
    private static final int[][] steps8 = {
            {-1, 0}, {1, 0}, {0, -1}, {0, 1},
            {-1, -1}, {1, 1}, {1, -1}, {-1, 1}
    };

    private static boolean checkCell(int row, int rowsCount, int column, int columnsCount) {
        return checkIndex(row, rowsCount) && checkIndex(column, columnsCount);
    }

    private static boolean checkIndex(int index, int lim){
        return (0 <= index && index < lim);
    }

    /////////////////////////////////////////////////////////////////////

    private static int getBit(long mask, int bit) { return (int)((mask >> bit) & 1); }
    private static boolean checkBit(long mask, int bit){
        return getBit(mask, bit) != 0;
    }

    /////////////////////////////////////////////////////////////////////

    private static long getSum(int[] array) {
        long sum = 0;
        for (int value: array) {
            sum += value;
        }

        return sum;
    }

    private static Point getMinMax(int[] array) {
        int min = array[0];
        int max = array[0];

        for (int index = 0, size = array.length; index < size; ++index, ++index) {
            int value = array[index];

            if (index == size - 1) {
                min = min(min, value);
                max = max(max, value);
            } else {
                int otherValue = array[index + 1];

                if (value <= otherValue) {
                    min = min(min, value);
                    max = max(max, otherValue);
                } else {
                    min = min(min, otherValue);
                    max = max(max, value);
                }
            }
        }

        return new Point(min, max);
    }

    /////////////////////////////////////////////////////////////////////

    private static int[] getPrimes(int n) {
        boolean[] used = new boolean[n];
        used[0] = used[1] = true;

        int size = 0;
        for (int i = 2; i < n; ++i) {
            if (!used[i]) {
                ++size;
                for (int j = 2 * i; j < n; j += i) {
                    used[j] = true;
                }
            }
        }

        int[] primes = new int[size];
        for (int i = 0, cur = 0; i < n; ++i) {
            if (!used[i]) {
                primes[cur++] = i;
            }
        }

        return primes;
    }

    /////////////////////////////////////////////////////////////////////

    int[] getDivisors(int value) {
        List<Integer> divisors = new ArrayList<Integer>();
        for (int divisor = 1; divisor * divisor <= value; ++divisor) {
            if (value % divisor == 0) {
                divisors.add(divisor);
                if (divisor * divisor != value) {
                    divisors.add(value / divisor);
                }
            }
        }

        return castInt(divisors);
    }

    /////////////////////////////////////////////////////////////////////

    private static long lcm(long a, long b) {
        return a / gcd(a, b) * b;
    }

    private static long gcd(long a, long b) {
        return (a == 0 ? b : gcd(b % a, a));
    }

/////////////////////////////////////////////////////////////////////

    private interface MultiSet<ValueType> {

        int size();

        void inc(ValueType value);
        boolean dec(ValueType value);

        int count(ValueType value);
    }

    private static abstract class MultiSetImpl
            <ValueType, MapType extends Map<ValueType, Integer>>
            implements MultiSet<ValueType> {

        protected final MapType map;
        protected int size;

        protected MultiSetImpl(MapType map) {
            this.map = map;
            this.size = 0;
        }

        public int size() {
            return size;
        }

        public void inc(ValueType value) {
            int count = count(value);
            map.put(value, count + 1);

            ++size;
        }

        public boolean dec(ValueType value) {
            int count = count(value);
            if (count == 0) return false;

            if (count == 1) map.remove(value);
            else map.put(value, count - 1);

            --size;
            return true;
        }

        public int count(ValueType value) {
            Integer count = map.get(value);
            return (count == null ? 0 : count);
        }
    }

    private static class HashMultiSet<ValueType>
            extends MultiSetImpl<ValueType, Map<ValueType, Integer>> {

        public static <ValueType> MultiSet<ValueType> createMultiSet() {
            Map<ValueType, Integer> map = new HashMap<ValueType, Integer>();
            return new HashMultiSet<ValueType>(map);
        }

        HashMultiSet(Map<ValueType, Integer> map) {
            super(map);
        }
    }

    /////////////////////////////////////////////////////////////////////

    private interface SortedMultiSet<ValueType> extends MultiSet<ValueType> {

        ValueType min();
        ValueType max();

        ValueType pollMin();
        ValueType pollMax();

        ValueType lower(ValueType value);
        ValueType floor(ValueType value);

        ValueType ceiling(ValueType value);
        ValueType higher(ValueType value);
    }

    private static abstract class SortedMultiSetImpl<ValueType>
            extends MultiSetImpl<ValueType, NavigableMap<ValueType, Integer>>
            implements SortedMultiSet<ValueType> {

        SortedMultiSetImpl(NavigableMap<ValueType, Integer> map) {
            super(map);
        }

        @Override
        public ValueType min() {
            return (size == 0 ? null : map.firstKey());
        }

        @Override
        public ValueType max() {
            return (size == 0 ? null : map.lastKey());
        }

        @Override
        public ValueType pollMin() {
            ValueType first = min();
            if (first != null) dec(first);
            return first;
        }

        @Override
        public ValueType pollMax() {
            ValueType last = max();
            dec(last);
            return last;
        }

        @Override
        public ValueType lower(ValueType value) {
            return map.lowerKey(value);
        }

        @Override
        public ValueType floor(ValueType value) {
            return map.floorKey(value);
        }

        @Override
        public ValueType ceiling(ValueType value) {
            return map.ceilingKey(value);
        }

        @Override
        public ValueType higher(ValueType value) {
            return map.higherKey(value);
        }
    }

    private static class TreeMultiSet<ValueType>
            extends SortedMultiSetImpl<ValueType> {

        public static <ValueType> SortedMultiSet<ValueType> createMultiSet() {
            NavigableMap<ValueType, Integer> map = new TreeMap<ValueType, Integer>();
            return new TreeMultiSet<ValueType>(map);
        }

        TreeMultiSet(NavigableMap<ValueType, Integer> map) {
            super(map);
        }
    }

    /////////////////////////////////////////////////////////////////////

    private static class IdMap<KeyType> extends HashMap<KeyType, Integer> {

        /**
         *
         */
        private static final long serialVersionUID = -3793737771950984481L;

        public IdMap() {
            super();
        }

        int register(KeyType key) {
            Integer id = super.get(key);
            if (id == null) {
                super.put(key, id = size());
            }

            return id;
        }

        int getId(KeyType key) {
            return get(key);
        }
    }

    /////////////////////////////////////////////////////////////////////

    private static class SortedIdMapper<ValueType extends Comparable<ValueType>> {

        private List<ValueType> values;

        public SortedIdMapper() {
            this.values = new ArrayList<ValueType>();
        }

        void addValue(ValueType value) {
            values.add(value);
        }

        IdMap<ValueType> build() {
            Collections.sort(values);

            IdMap<ValueType> ids = new IdMap<ValueType>();
            List<ValueType> uniqueValues = new ArrayList<ValueType>();

            for (int index = 0; index < values.size(); ++index) {
                ValueType value = values.get(index);
                if (index == 0 || values.get(index - 1).compareTo(value) != 0) {
                    ids.register(value);
                    uniqueValues.add(value);
                }
            }

            values = uniqueValues;

            return ids;
        }
    }

    /////////////////////////////////////////////////////////////////////

    private static int[] castInt(List<Integer> list) {
        int[] array = new int[list.size()];
        for (int i = 0; i < array.length; ++i) {
            array[i] = list.get(i);
        }

        return array;
    }

    private static long[] castLong(List<Long> list) {
        long[] array = new long[list.size()];
        for (int i = 0; i < array.length; ++i) {
            array[i] = list.get(i);
        }

        return array;
    }

    /////////////////////////////////////////////////////////////////////

    /**
     * Generates list with keys 0..<n
     * @param n - exclusive limit of sequence
     */
    private static List<Integer> order(int n) {
        List<Integer> sequence = new ArrayList<Integer>();
        for (int i = 0; i < n; ++i) {
            sequence.add(i);
        }

        return sequence;
    }

    /////////////////////////////////////////////////////////////////////

    interface Rmq {
        int getMin(int left, int right);
        int getMinIndex(int left, int right);
    }

    private static class SparseTable implements Rmq {

        private static final int MAX_BIT = 20;

        int n;
        int[] array;

        SparseTable(int[] array) {
            this.n = array.length;
            this.array = array;
        }

        int[] lengthMaxBits;
        int[][] table;

        int getIndexOfLess(int leftIndex, int rightIndex) {
            return (array[leftIndex] <= array[rightIndex])
                    ? leftIndex
                    : rightIndex;
        }

        SparseTable build() {
            this.lengthMaxBits = new int[n + 1];
            lengthMaxBits[0] = 0;
            for (int i = 1; i <= n; ++i) {
                lengthMaxBits[i] = lengthMaxBits[i - 1];
                int length = (1 << lengthMaxBits[i]);
                if (length + length <= i) ++lengthMaxBits[i];
            }

            this.table = new int[MAX_BIT][n];
            table[0] = castInt(order(n));

            for (int bit = 0; bit < MAX_BIT - 1; ++bit) {
                for (int i = 0, j = (1 << bit); j < n; ++i, ++j) {
                    table[bit + 1][i] = getIndexOfLess(
                            table[bit][i], table[bit][j]
                    );
                }
            }

            return this;
        }

        @Override
        public int getMinIndex(int left, int right) {
            int length = (right - left + 1);

            int bit = lengthMaxBits[length];
            int segmentLength = (1 << bit);

            return getIndexOfLess(
                    table[bit][left], table[bit][right - segmentLength + 1]
            );
        }

        @Override
        public int getMin(int left, int right) {
            return array[getMinIndex(left, right)];
        }
    }

    private static Rmq createRmq(int[] array) {
        return new SparseTable(array).build();
    }

    /////////////////////////////////////////////////////////////////////

    interface Lca {
        Lca build(int root);
        int lca(int a, int b);

        int height(int v);
    }

    private static class LcaRmq implements Lca {

        int n;
        int[][] graph;

        LcaRmq(int[][] graph) {
            this.n = graph.length;
            this.graph = graph;
        }

        int time;

        int[] order;
        int[] heights;
        int[] first;

        Rmq rmq;

        @Override
        public LcaRmq build(int root) {
            this.order = new int[n + n];
            this.heights = new int[n];

            this.first = new int[n];
            Arrays.fill(first, -1);

            this.time = 0;
            dfs(root, 0);

            int[] orderedHeights = new int[n + n];
            for (int i = 0; i < order.length; ++i) {
                orderedHeights[i] = heights[order[i]];
            }

            this.rmq = createRmq(orderedHeights);
            return this;
        }

        void dfs(int from, int height) {
            first[from] = time;
            order[time] = from;
            heights[from] = height;
            ++time;

            for (int to : graph[from]) {
                if (first[to] == -1) {
                    dfs(to, height + 1);

                    order[time] = from;
                    ++time;
                }
            }
        }

        @Override
        public int lca(int a, int b) {
            int aFirst = first[a], bFirst = first[b];
            int left = min(aFirst, bFirst), right = max(aFirst, bFirst);

            int orderIndex = rmq.getMinIndex(left, right);
            return order[orderIndex];
        }

        @Override
        public int height(int v) {
            return heights[v];
        }
    }

    private static class LcaBinary implements Lca {

        private static final int MAX_BIT = 20;

        int n;
        int[][] graph;

        int[] h;
        int[][] parents;

        LcaBinary(int[][] graph) {
            this.n = graph.length;
            this.graph = graph;
        }

        @Override
        public Lca build(int root) {
            this.h = new int[n];

            this.parents = new int[MAX_BIT][n];
            Arrays.fill(parents[0], -1);

            Queue<Integer> queue = new ArrayDeque<Integer>();

            queue.add(root);
            add(root, root);

            while (queue.size() > 0) {
                int from = queue.poll();
                for (int to : graph[from]) {
                    if (parents[0][to] == -1) {
                        add(from, to);
                        queue.add(to);
                    }
                }
            }

            return this;
        }

        void add(int parent, int v) {
            h[v] = h[parent] + 1;
            parents[0][v] = parent;
            for (int bit = 0; bit < MAX_BIT - 1; ++bit) {
                parents[bit + 1][v] = parents[bit][parents[bit][v]];
            }
        }

        @Override
        public int lca(int a, int b) {
            if (h[a] < h[b]) {
                int tmp = a;
                a = b;
                b = tmp;
            }

            int delta = h[a] - h[b];
            for (int bit = MAX_BIT - 1; bit >= 0; --bit) {
                if (delta >= (1 << bit)) {
                    delta -= (1 << bit);
                    a = parents[bit][a];
                }
            }

            if (a == b) return a;

            for (int bit = MAX_BIT - 1; bit >= 0; --bit) {
                int nextA = parents[bit][a], nextB = parents[bit][b];
                if (nextA != nextB) {
                    a = nextA;
                    b = nextB;
                }
            }

            return parents[0][a];
        }

        @Override
        public int height(int v) {
            return h[v];
        }
    }

    private static Lca createLca(int[][] graph, int root) {
        return new LcaRmq(graph).build(root);
    }

    /////////////////////////////////////////////////////////////////////

    private static class BiconnectedGraph {

        int n;
        int[][] graph;

        BiconnectedGraph(int[][] graph) {
            this.n = graph.length;
            this.graph = graph;
        }

        int time;
        int[] tin, up;

        boolean[] used;

        BiconnectedGraph build() {
            calculateTimes();
            condensateComponents();

            return this;
        }

        void calculateTimes() {
            this.tin = new int[n];
            this.up = new int[n];

            this.time = 0;

            this.used = new boolean[n];
            timeDfs(0, -1);
        }

        void timeDfs(int from, int parent) {
            used[from] = true;

            up[from] = tin[from] = time;
            ++time;

            for (int to : graph[from]) {
                if (to == parent) continue;

                if (used[to]) {
                    up[from] = min(up[from], tin[to]);
                } else {
                    timeDfs(to, from);
                    up[from] = min(up[from], up[to]);
                }
            }
        }

        int[] components;
        int[][] componentsGraph;

        int component(int v) { return components[v]; }

        int[][] toGraph() {
            return componentsGraph;
        }

        void condensateComponents() {
            this.components = new int[n];
            Arrays.fill(components, -1);

            for (int v = 0; v < n; ++v) {
                if (components[v] == -1) {
                    componentsDfs(v, v);
                }
            }

            GraphBuilder graphBuilder = GraphBuilder.createInstance(n);

            Set<Point> edges = new HashSet<Point>();
            for (int from = 0; from < n; ++from) {
                int fromComponent = components[from];

                for (int to : graph[from]) {
                    int toComponent = components[to];
                    if (fromComponent == toComponent) continue;

                    Point edge = new Point(fromComponent, toComponent);
                    if (edges.add(edge)) graphBuilder.addDirectedEdge(fromComponent, toComponent);
                }
            }

            this.componentsGraph = graphBuilder.build();
        }

        void componentsDfs(int from, int color) {
            components[from] = color;
            for (int to : graph[from]) {
                if (components[to] != -1) continue;

                if (tin[from] >= up[to] && tin[to] >= up[from]) {
                    componentsDfs(to, color);
                }
            }
        }
    }

    /////////////////////////////////////////////////////////////////////

    private static class VertexBiconnectedGraph {

        static class Edge {
            int to;
            int index;

            Edge(int to, int index) {
                this.to = to;
                this.index = index;
            }
        }

        int n, m;
        List<Edge>[] graph;
        List<Edge> edges;

        VertexBiconnectedGraph(int n) {
            this.n = n;
            this.m = 0;

            this.graph = new List[n];
            for (int v = 0; v < n; ++v) {
                graph[v] = new ArrayList<Edge>();
            }

            this.edges = new ArrayList<Edge>();
        }

        void addEdge(int from, int to) {
            Edge fromToEdge = new Edge(to, m);
            Edge toFromEdge = new Edge(from, m + 1);

            edges.add(fromToEdge);
            edges.add(toFromEdge);

            graph[from].add(fromToEdge);
            graph[to].add(toFromEdge);

            m += 2;
        }

        int time;

        boolean[] used;
        int[] tin, up;
        int[] parents;

        boolean[] isArticulation;

        boolean[] findArticulationPoints() {
            this.isArticulation = new boolean[n];

            this.used = new boolean[n];
            this.parents = new int[n];
            Arrays.fill(parents, -1);

            this.tin = new int[n];
            this.up = new int[n];

            this.time = 0;

            for (int v = 0; v < n; ++v) {
                if (!used[v]) {
                    articulationDfs(v, -1);
                }
            }

            return isArticulation;
        }

        void articulationDfs(int from, int parent) {
            used[from] = true;
            parents[from] = parent;

            ++time;
            up[from] = tin[from] = time;

            int childrenCount = 0;

            for (Edge e : graph[from]) {
                int to = e.to;

                if (to == parent) continue;

                if (used[to]) {
                    up[from] = min(up[from], tin[to]);
                } else {
                    ++childrenCount;

                    articulationDfs(to, from);
                    up[from] = min(up[from], up[to]);
                    if (up[to] >= tin[from] && parent != -1) {
                        isArticulation[from] = true;
                    }
                }
            }

            if (parent == -1 && childrenCount > 1) {
                isArticulation[from] = true;
            }
        }

        int[] edgeColors;
        int maxEdgeColor;

        int[] paintEdges() {
            this.edgeColors = new int[m];
            Arrays.fill(edgeColors, -1);

            this.maxEdgeColor = -1;

            this.used = new boolean[n];

            for (int v = 0; v < n; ++v) {
                if (!used[v]) {
                    ++maxEdgeColor;
                    paintDfs(v, maxEdgeColor, -1);
                }
            }

            return edgeColors;
        }

        void paintEdge(int edgeIndex, int color) {
            if (edgeColors[edgeIndex] != -1) return;

            edgeColors[edgeIndex] = edgeColors[edgeIndex ^ 1] = color;
        }

        void paintDfs(int from, int color, int parent) {
            used[from] = true;

            for (Edge e : graph[from]) {
                int to = e.to;
                if (to == parent) continue;

                if (!used[to]) {
                    if (up[to] >= tin[from]) {
                        int newColor = ++maxEdgeColor;
                        paintEdge(e.index, newColor);
                        paintDfs(to, newColor, from);
                    } else {
                        paintEdge(e.index, color);
                        paintDfs(to, color, from);
                    }
                } else if (up[to] <= tin[from]){
                    paintEdge(e.index, color);
                }
            }
        }

        Set<Integer>[] collectVertexEdgeColors() {
            Set<Integer>[] vertexEdgeColors = new Set[n];
            for (int v = 0; v < n; ++v) {
                vertexEdgeColors[v] = new HashSet<Integer>();
                for (Edge e : graph[v]) {
                    vertexEdgeColors[v].add(edgeColors[e.index]);
                }
            }

            return vertexEdgeColors;
        }

        VertexBiconnectedGraph build() {
            findArticulationPoints();
            paintEdges();
            createComponentsGraph();

            return this;
        }

        int[][] componentsGraph;

        void createComponentsGraph() {
            Set<Integer>[] vertexEdgeColors = collectVertexEdgeColors();

            int edgeColorShift = vertexEdgeColors.length;
            int size = vertexEdgeColors.length + maxEdgeColor + 1;

            GraphBuilder graphBuilder = GraphBuilder.createInstance(size);
            for (int v = 0; v < vertexEdgeColors.length; ++v) {
                for (int edgeColor : vertexEdgeColors[v]) {
                    graphBuilder.addEdge(v, edgeColor + edgeColorShift);
                }
            }

            this.componentsGraph = graphBuilder.build();
        }

        int[][] toGraph() {
            return componentsGraph;
        }
    }

    /////////////////////////////////////////////////////////////////////

    private static class DSU {

        int[] sizes;

        int[] ranks;
        int[] parents;

        static DSU createInstance(int size) {
            int[] sizes = new int[size];
            Arrays.fill(sizes, 1);

            return new DSU(sizes);
        }

        DSU(int[] sizes) {
            this.sizes = sizes;

            int size = sizes.length;

            this.ranks = new int[size];
            Arrays.fill(ranks, 1);

            this.parents = castInt(order(size));
        }

        int get(int v) {
            if (v == parents[v]) return v;
            return parents[v] = get(parents[v]);
        }

        boolean union(int a, int b) {
            a = get(a);
            b = get(b);

            if (a == b) return false;

            if (ranks[a] < ranks[b]) {
                int tmp = a;
                a = b;
                b = tmp;
            }

            parents[b] = a;
            sizes[a] += sizes[b];

            if (ranks[a] == ranks[b]) ++ranks[a];

            return true;
        }
    }

    /////////////////////////////////////////////////////////////////////

    static abstract class SegmentTree {

    	int size;
    	boolean lazySupported;

    	boolean[] lazy;
    	long[] values;

    	long[] tree;

    	SegmentTree(int n, boolean lazySupported) {
    		this.size = n;
    		this.lazySupported = lazySupported;

    		int treeSize = size << 2;

    		this.tree = new long[treeSize];

    		if (lazySupported) {
        		this.lazy = new boolean[treeSize];
        		this.values = new long[treeSize];
    		}
    	}

    	SegmentTree(int[] a, boolean lazySupported) {
    		this(a.length, lazySupported);
    	}

    	abstract void updateValue(int v, long value);

    	void setLazyValue(int v, long value) {
    		throw new UnsupportedOperationException();
    	}

    	void pushVertex(int v, int vLeft, int vRight) {
    		if (lazy[v]) {
    			setLazyValue(vLeft, values[v]);
    			setLazyValue(vRight, values[v]);

    			lazy[v] = false;
    			values[v] = 0;
    		}
    	}

    	abstract void updateVertex(int v, int vLeft, int vRight);

    	int[] a;
    	void buildTree(int[] a) {
    		this.a = a;

    		buildTree(1, 0, size - 1);
    	}

    	void buildTree(int v, int left, int right) {
    		if (left == right) {
    			updateValue(v, a[left]);
    		} else {
    			int mid = (left + right) >> 1;
    			int vLeft = (v << 1), vRight = (vLeft + 1);

    			buildTree(vLeft, left, mid);
    			buildTree(vRight, mid + 1, right);

    			updateVertex(v, vLeft, vRight);
    		}
    	}

    	long value;

    	int index;
    	void updateIndex(int index, long value) {
    		this.index = index;
    		this.value = value;

    		updateTreeIndex(1, 0, size - 1);
    	}

    	void updateTreeIndex(int v, int left, int right) {
    		if (left == right) {
    			updateValue(v, value);
    		} else {
    			int mid = (left + right) >> 1;
    			int vLeft = (v << 1), vRight = (vLeft + 1);

    			if (index <= mid) updateTreeIndex(vLeft, left, mid);
    			else updateTreeIndex(vRight, mid + 1, right);

    			updateVertex(v, vLeft, vRight);
    		}
    	}

    	int start, end;
    	void updateSegment(int start, int end, long value) {
    		this.start = start;
    		this.end = end;
    		this.value = value;

    		updateTreeSegment(1, 0, size - 1);
    	}

    	void updateTreeSegment(int v, int left, int right) {
    		if (start <= left && right <= end) {
    			if (lazySupported) {
    				setLazyValue(v, value);
    			} else {
    				updateValue(v, value);
    			}
    		} else {
    			int mid = (left + right) >> 1;
    			int vLeft = (v << 1), vRight = (vLeft + 1);

    			if (lazySupported) pushVertex(v, vLeft, vRight);

    			if (start <= mid) updateTreeSegment(vLeft, left, mid);
    			if (mid < end) updateTreeSegment(vRight, mid + 1, right);

    			updateVertex(v, vLeft, vRight);
    		}
    	}

    	abstract void initResult(long... initResultValues);

    	abstract void accumulateResult(int v, int left, int right);

    	void getIndex(int index, long... initResultValues) {
    		this.index = index;

    		initResult(initResultValues);

    		getTreeIndex(1, 0, size - 1);
    	}

    	void getTreeIndex(int v, int left, int right) {
    		if (lazySupported) {
    			if (left == right) {
    				accumulateResult(v, left, right);
    			} else {
    				int mid = (left + right) >> 1;
    				int vLeft = (v << 1), vRight = (vLeft + 1);

    				pushVertex(v, vLeft, vRight);

    				if (index <= mid) getTreeIndex(vLeft, left, mid);
    				else getTreeIndex(vRight, mid + 1, right);

    				updateVertex(v, vLeft, vRight);
    			}
    		} else {
    			while (left <= right) {
        			accumulateResult(v, left, right);

        			if (left == right) break;

    				int mid = (left + right) >> 1;
    				int vLeft = (v << 1), vRight = (vLeft + 1);

        			if (index <= mid) {
        				v = vLeft;
        				right = mid;
        			} else {
        				v = vRight;
        				left = mid + 1;
        			}
    			}
    		}
    	}

    	void getSegment(int start, int end, long... initResultValues) {
    		this.start = start;
    		this.end = end;

    		initResult(initResultValues);

    		getTreeSegment(1, 0, size - 1);
    	}

    	void getTreeSegment(int v, int left, int right) {
    		if (start <= left && right <= end) {
    			accumulateResult(v, left, right);
    		} else {
    			int mid = (left + right) >> 1;
				int vLeft = (v << 1), vRight = (vLeft + 1);

				if (lazySupported) pushVertex(v, vLeft, vRight);

				if (start <= mid) getTreeSegment(vLeft, left, mid);
				if (mid < end) getTreeSegment(vRight, mid + 1, right);

				if (lazySupported) updateVertex(v, vLeft, vRight);
    		}
    	}

    	int[] toArray() {
    		this.a = new int[size];

    		fillTreeArray(1, 0, size - 1);

    		return a;
    	}

    	void fillTreeArray(int v, int left, int right) {
    		if (left == right) {
    			a[left] = (int)(tree[v]);
    		} else {
    			int mid = (left + right) >> 1;
				int vLeft = (v << 1), vRight = (vLeft + 1);

				if (lazySupported) pushVertex(v, vLeft, vRight);

				fillTreeArray(vLeft, left, mid);
				fillTreeArray(vRight, mid + 1, right);

				if (lazySupported) updateVertex(v, vLeft, vRight);
    		}
    	}
    }

    /////////////////////////////////////////////////////////////////////
}

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;

public class D {

	static int k;
	static int pa, pb, inv, pbinv;
	static final int MOD = (int) 1e9 + 7;

	static int memo[][];

	static int pow(int x, int p) {
		if(p == 0)
			return 1;
		long ans = 1;
		if(p % 2 == 1)
			ans = x;

		long c = pow(x, p / 2);
		ans *= c;
		ans %= MOD;
		ans *= c;
		ans %= MOD;
		return (int) ans;
	}

	static int solve(int a, int s) {
		if(s >= k)
			return s;

		if(a >= k)  {
			return (int) ((1l * (pa + pb) * pbinv % MOD + a + s - 1 + MOD) % MOD);
		}

		if(memo[a][s] != -1)
			return memo[a][s];

		return memo[a][s] = (int)  ((1l * pa * solve(a + 1, s) % MOD * inv % MOD + 1l * pb * solve(a, s + a) % MOD * inv % MOD) % MOD);
	}
	public static void main(String[] args) throws IOException {
		Scanner sc = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);

		k = sc.nextInt();
		pa = sc.nextInt();
		pb = sc.nextInt();

		inv = pow(pa + pb, MOD - 2);
		pbinv = pow(pb, MOD - 2);

		memo = new int[k + 5][k + 5];
		for(int[] a : memo)
			Arrays.fill(a, -1);
		out.println(solve(1, 0));

		out.flush();
		out.close();
	}

	static class Scanner {
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}

		public Scanner(String file) throws FileNotFoundException {
			br = new BufferedReader(new FileReader(file));
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

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

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

		public String nextLine() throws IOException {
			return br.readLine();
		}

		public double nextDouble() throws IOException {
			String x = next();
			StringBuilder sb = new StringBuilder("0");
			double res = 0, f = 1;
			boolean dec = false, neg = false;
			int start = 0;
			if (x.charAt(0) == '-') {
				neg = true;
				start++;
			}
			for (int i = start; i < x.length(); i++)
				if (x.charAt(i) == '.') {
					res = Long.parseLong(sb.toString());
					sb = new StringBuilder("0");
					dec = true;
				} else {
					sb.append(x.charAt(i));
					if (dec)
						f *= 10;
				}
			res += Long.parseLong(sb.toString()) / f;
			return res * (neg ? -1 : 1);
		}

		public boolean ready() throws IOException {
			return br.ready();
		}

	}
}

import java.io.*;
import java.util.*;

public class utkarsh{
	BufferedReader br;
	PrintWriter out;

	long mod = (long)1e9 + 7;

	long modpow(long b, long e){
		long r = 1;
		while(e > 0){
			if((e&1) == 1){
				r *= b;	r %= mod;
			}
			b *= b;	b %= mod;
			e >>= 1;
		}
		return r;
	}

	long dp[][], pa, pb, abyb, a_b;
	int k;

	long play(int a, int ab){
		if(ab >= k)	return ab;
		if(a >= k)	return (a + ab + abyb) % mod;
		if(dp[a][ab] != 0)	return dp[a][ab];
		long ans = play(a+1, ab) * pa + play(a, ab + a) * pb;
		ans %= mod;
		dp[a][ab] = ans;
		return ans;
	}

	void solve(){
		br = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);

		k = ni();	pa = ni();	pb = ni();
		a_b = modpow(pa + pb, mod - 2);
		pa = pa * a_b % mod;
		pb = pb * a_b % mod;
		abyb = pa * modpow(pb, mod - 2) % mod;
		dp = new long[k][k];
		out.println(play(1, 0));

		out.flush();
	}

	int ni(){
		return Integer.parseInt(ns());
	}

	String ip[];
	int len, sz;

	String ns(){
		if(len >= sz){
			try{
				ip = br.readLine().split(" ");
				len = 0;
				sz = ip.length;
			}catch(IOException e){
				throw new InputMismatchException();
			}
			if(sz <= 0)	return "-1";
		}
		return ip[len++];
	}

	public static void main(String[] args){	new utkarsh().solve();	}
}

import java.util.*;
import java.io.*;
import java.math.*;
public class A{

    void solve(){
        k=ni();
        long pa=ni(),pb=ni();
        p1=(pa*modInverse(pa+pb,M))%M;
        p2=(pb*modInverse(pa+pb,M))%M;
        dp=new long[k+1][k+1];
        for(int i=0;i<=k;i++)Arrays.fill(dp[i],-1);
        long ans=go(1,0)%M;

        pw.println(ans);

    }
    int k;
    long p1,p2;
    long dp[][];
    long go(int a, int cnt){
        if(cnt>=k) {
            long d=((cnt)%M +(p1*modInverse(p2,M))%M) % M;
            return d;
        }
        if(a+cnt>=k) {
            long d=((cnt + a)%M +(p1*modInverse(p2,M))%M) % M;
            return d;

        }
        if(dp[a][cnt]!=-1) return dp[a][cnt];

        long cc=0;
        cc=(cc+p1*go(a+1,cnt)%M)%M;
        cc=(cc+p2*go(a,cnt+a)%M)%M;
        dp[a][cnt]=cc;
        return cc;
    }

    static long d, x, y;
    static void extendedEuclid(long A, long B) {
        if(B == 0) {
            d = A;
            x = 1;
            y = 0;
        }
        else {
            extendedEuclid(B, A%B);
            long temp = x;
            x = y;
            y = temp - (A/B)*y;
        }
    }
    static long modInverse(long A, long M){
        extendedEuclid(A,M);
        return (x%M+M)%M;
    }

    long M=(long)1e9+7;
    InputStream is;
    PrintWriter pw;
    String INPUT = "";
    void run() throws Exception {
        is = INPUT.isEmpty() ? System.in : new ByteArrayInputStream(INPUT.getBytes());
        pw = new PrintWriter(System.out);
        long s = System.currentTimeMillis();
        solve();
        pw.flush();
        if(!INPUT.isEmpty())tr(System.currentTimeMillis()-s+"ms");
    }

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

    private byte[] inbuf = new byte[1024];
    public int lenbuf = 0, ptrbuf = 0;

    private int readByte() {
        if(lenbuf == -1)throw new InputMismatchException();
        if(ptrbuf >= lenbuf){
            ptrbuf = 0;
            try { lenbuf = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }
            if(lenbuf <= 0)return -1;
        }
        return inbuf[ptrbuf++];
    }

    private boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }
    private int skip() { int b; while((b = readByte()) != -1 && isSpaceChar(b)); return b; }

    private double nd() { return Double.parseDouble(ns()); }
    private char nc() { return (char)skip(); }

    private String ns() {
        int b = skip();
        StringBuilder sb = new StringBuilder();
        while(!(isSpaceChar(b))){ // when nextLine, (isSpaceChar(b) && b != ' ')
            sb.appendCodePoint(b);
            b = readByte();
        }
        return sb.toString();
    }

    private char[] ns(int n) {
        char[] buf = new char[n];
        int b = skip(), p = 0;
        while(p < n && !(isSpaceChar(b))){
            buf[p++] = (char)b;
            b = readByte();
        }
        return n == p ? buf : Arrays.copyOf(buf, p);
    }

    private char[][] nm(int n, int m) {
        char[][] map = new char[n][];
        for(int i = 0;i < n;i++)map[i] = ns(m);
        return map;
    }

    private int[] na(int n) {
        int[] a = new int[n];
        for(int i = 0;i < n;i++)a[i] = ni();
        return a;
    }

    private int ni() {
        int num = 0, b;
        boolean minus = false;
        while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
        if(b == '-'){
            minus = true;
            b = readByte();
        }

        while(true){
            if(b >= '0' && b <= '9'){
                num = num * 10 + (b - '0');
            }else{
                return minus ? -num : num;
            }
            b = readByte();
        }
    }

    private long nl() {
        long num = 0;
        int b;
        boolean minus = false;
        while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
        if(b == '-'){
            minus = true;
            b = readByte();
        }

        while(true){
            if(b >= '0' && b <= '9'){
                num = num * 10 + (b - '0');
            }else{
                return minus ? -num : num;
            }
            b = readByte();
        }
    }

    private void tr(Object... o) { if(INPUT.length() > 0)System.out.println(Arrays.deepToString(o)); }
}

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

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskD solver = new TaskD();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskD {
        static final long MODULO = (long) 1e9 + 7;

        long pow(long a, long k) {
            if (k == 0) return 1;
            if (k % 2 == 0) return pow(a * a % MODULO, k / 2);
            return a * pow(a, k - 1) % MODULO;
        }

        long inv(long a) {
            return pow(a, MODULO - 2);
        }

        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int k = in.nextInt();
            int pa = in.nextInt();
            int pb = in.nextInt();
            long pra = pa * inv(pa + pb) % MODULO;
            long prb = pb * inv(pa + pb) % MODULO;
            long invpra = inv(pra);
            long invprb = inv(prb);
            int[][] expect = new int[k + 1][];
            for (int togo = 1; togo <= k; ++togo) {
                expect[togo] = new int[togo + 1];
                expect[togo][togo] = (int) ((togo + (1 - prb + MODULO) * invprb) % MODULO);
                for (int have = togo - 1; have >= 0; --have) {
                    {
                        // get a
                        expect[togo][have] = (int) ((expect[togo][have] + (have == 0 ? 1 : pra) * expect[togo][have + 1]) % MODULO);
                    }
                    if (have > 0) {
                        // get b
                        int ntogo = togo - have;
                        int extra = have;
                        int nhave = have;
                        if (have > ntogo) {
                            extra += have - ntogo;
                            nhave = ntogo;
                        }
                        expect[togo][have] = (int) ((expect[togo][have] + prb * (extra + expect[ntogo][nhave])) % MODULO);
                    }
                }
            }
            out.println(expect[k][0]);
        }

    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

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

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

    }
}

import java.util.*;
import java.io.*;

public class D2017 {
    public static void main(String[] args) {
        MyScanner sc = new MyScanner();
        PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
        int k = sc.nextInt();
        int a = sc.nextInt(); int b = sc.nextInt();
        long pa = (a * inv(a + b)) % mod; long pb = (b * inv(a + b)) % mod;
        // number of subsequences, number of a's
        long [][] dp = new long[k + 1][k + 1];
        for (int i = 0; i <= k; i++) {
            dp[i][k] = (i + k + (inv(pb) - 1) % mod) % mod;
            if (dp[i][k] < 0) dp[i][k] += mod;
            dp[k][i] = k;
        }
        for (int i = k - 1; i >= 0; i--) {
            for (int j = k - 1; j >= 0; j--) {
                if (j == 0 && i > 0) continue;
                dp[i][j] = (dp[i][j] + (pa * dp[i][j + 1]) % mod) % mod;
                if (i == 0 && j == 0) break;
                if (i + j >= k) {
                    dp[i][j] = (dp[i][j] + (pb * (i + j)) % mod) % mod;
                } else {
                    dp[i][j] = (dp[i][j] + (pb * dp[i + j][j]) % mod) % mod;
                }
            }
        }
        out.println(dp[0][1]);
        out.close();
    }

    static long[] fac;
    static long mod = (long) 1e9 + 7;

    static void initFac(long n) {
        fac = new long[(int)n + 1];
        fac[0] = 1;
        for (int i = 1; i <= n; i++) {
            fac[i] = (fac[i - 1]  * i) % mod;
        }
    }

    static long nck(int n, int k) {
        if (n < k)
            return 0;
        long den = inv((int) (fac[k] * fac[n - k] % mod));
        return fac[n] * den % mod;
    }

    static long pow(long b, long e) {
        long ans = 1;
        while (e > 0) {
            if (e % 2 == 1)
                ans = ans * b % mod;
            e >>= 1;
            b = b * b % mod;
        }
        return ans;
    }

    static long inv(long x) {
        return pow(x, mod - 2);
    }

    //-----------MyScanner class for faster input----------
    public static class MyScanner {
        BufferedReader br;
        StringTokenizer st;

        public MyScanner() {
            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;
        }

    }

}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.Reader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        MyInput in = new MyInput(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskD solver = new TaskD();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskD {
        Fraction pa;
        Fraction pb;
        Fraction[][] memo = new Fraction[1001][1001];

        public void solve(int testNumber, MyInput in, PrintWriter out) {
            int k = in.nextInt();
            int ppa = in.nextInt();
            int ppb = in.nextInt();
            pa = new Fraction(ppa, ppa + ppb);
            pb = new Fraction(ppb, ppa + ppb);
            out.println(rec(1, k).toString());
        }

        Fraction rec(int a, int k) {
            if (memo[a][k] == null) {
                if (a >= k) {
                    memo[a][k] = pb.mul(a).addM(pa).divM(pb);
                } else {
                    memo[a][k] = rec(a + 1, k).mul(pa).addM(rec(a, k - a).add(a).mulM(pb));
                }
//            dump(a, k, memo[a][k].prettyPrint());
            }
            return memo[a][k];
        }

    }

    static class MyInput {
        private final BufferedReader in;
        private static int pos;
        private static int readLen;
        private static final char[] buffer = new char[1024 * 8];
        private static char[] str = new char[500 * 8 * 2];
        private static boolean[] isDigit = new boolean[256];
        private static boolean[] isSpace = new boolean[256];
        private static boolean[] isLineSep = new boolean[256];

        static {
            for (int i = 0; i < 10; i++) {
                isDigit['0' + i] = true;
            }
            isDigit['-'] = true;
            isSpace[' '] = isSpace['\r'] = isSpace['\n'] = isSpace['\t'] = true;
            isLineSep['\r'] = isLineSep['\n'] = true;
        }

        public MyInput(InputStream is) {
            in = new BufferedReader(new InputStreamReader(is));
        }

        public int read() {
            if (pos >= readLen) {
                pos = 0;
                try {
                    readLen = in.read(buffer);
                } catch (IOException e) {
                    throw new RuntimeException();
                }
                if (readLen <= 0) {
                    throw new MyInput.EndOfFileRuntimeException();
                }
            }
            return buffer[pos++];
        }

        public int nextInt() {
            int len = 0;
            str[len++] = nextChar();
            len = reads(len, isSpace);
            int i = 0;
            int ret = 0;
            if (str[0] == '-') {
                i = 1;
            }
            for (; i < len; i++) ret = ret * 10 + str[i] - '0';
            if (str[0] == '-') {
                ret = -ret;
            }
            return ret;
        }

        public char nextChar() {
            while (true) {
                final int c = read();
                if (!isSpace[c]) {
                    return (char) c;
                }
            }
        }

        int reads(int len, boolean[] accept) {
            try {
                while (true) {
                    final int c = read();
                    if (accept[c]) {
                        break;
                    }
                    if (str.length == len) {
                        char[] rep = new char[str.length * 3 / 2];
                        System.arraycopy(str, 0, rep, 0, str.length);
                        str = rep;
                    }
                    str[len++] = (char) c;
                }
            } catch (MyInput.EndOfFileRuntimeException e) {
            }
            return len;
        }

        static class EndOfFileRuntimeException extends RuntimeException {
        }

    }

    static class Fraction {
        static int mod = (int) 1e9 + 7;
        long numerator;
        long denominator;

        Fraction(long n, long d) {
            this.numerator = n;
            this.denominator = d;
        }

        Fraction mul(Fraction x) {
            return new Fraction(numerator * x.numerator % mod, denominator * x.denominator % mod);
        }

        Fraction mul(int x) {
            return new Fraction(numerator * x % mod, denominator);
        }

        Fraction mulM(Fraction x) {
            numerator = x.numerator * numerator % mod;
            denominator = x.denominator * denominator % mod;
            return this;
        }

        Fraction divM(Fraction x) {
            numerator = x.denominator * numerator % mod;
            denominator = x.numerator * denominator % mod;
            return this;
        }

        Fraction add(int x) {
            return new Fraction((numerator + x * denominator) % mod, denominator);
        }

        Fraction addM(Fraction x) {
            numerator = (numerator * x.denominator + x.numerator * denominator) % mod;
            denominator = denominator * x.denominator % mod;
            return this;
        }

        public String toString() {
            long t = numerator * inverseModPrime(denominator, mod) % mod;
            if (t < 0) t += mod;
            return t + "";
        }

        static long powmod(long n, long r, int m) {
            long res = 1;
            for (; r != 0; r >>>= 1, n = n * n % m) {
                if ((r & 1) == 1) {
                    res = res * n;
                    if (res >= m) {
                        res %= m;
                    }
                }
            }
            return res;
        }

        static long inverseModPrime(long n, int p) {
            return powmod(n, p - 2, p);
        }

    }
}

//package codeforces.GoodBye17;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;

public class D_
{
	static int mod = (int)1e9+7;
	static int[][] memo;
	static int a,b,k, a_b;
	static int sum1, pb, pa, sum2;
	public static void main(String[] args) throws IOException
	{
		Scanner sc = new Scanner(System.in);
		PrintWriter pw = new PrintWriter(System.out);

		k = sc.nextInt();
		a = sc.nextInt();
		b = sc.nextInt();
		a_b = sum(a, b);
		memo = new int[k+2][k+2];
		for (int i = 0; i < memo.length; i++)
			Arrays.fill(memo[i], -1);
		pa = mult(a, inv(a_b, mod));
		pb = mult(b, inv(a_b, mod));
		sum1 = mult(a+b, inv(b, mod));
		sum2 = mult(mult(a, a+b), inv(mult(b, b), mod));
		System.out.println(solve(1, 0));

		pw.flush();
		pw.close();
	}

	static int sub(int a, int b)
	{
		int ans = a-b;
		ans %= mod;
		if(ans < 0)
			ans += mod;
		return ans;
	}

	private static int solve(int cntA, int tot)
	{
		if(tot >= k)
			return tot;
		if(cntA+tot >= k)
		{
			return memo[cntA][tot] = mult(pb, sum(mult(sum(tot, cntA), sum1), sum2));
			// pb * ((tot+cntA)(sum1) + sum2)
		}

		if(memo[cntA][tot] != -1)
			return memo[cntA][tot];

		// a
		int ans = mult(pa, solve(cntA+1, tot));
		// b
		ans = sum(ans, mult(pb, solve(cntA, tot+cntA)));

		return memo[cntA][tot] = ans;
	}

	static int mult(int a, int b)
	{
		return (int)(1l*a*b % mod);
	}

	static int sum(int a, int b)
	{
		return (a+b) % mod;
	}

	static int inv(long  x , long mod){
		long r, y;
		for(r = 1 , y = mod - 2 ; y != 0 ;x = x * x % mod, y>>=1)
		if ((y & 1) == 1)
		r = r * x % mod;
		return (int)r;
		}

	static class Scanner
	{
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s)
		{
			br = new BufferedReader(new InputStreamReader(s));
		}

		public Scanner(String s) throws FileNotFoundException
		{
			br = new BufferedReader(new FileReader(new File((s))));
		}

		public String next() throws IOException
		{
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

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

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

		public String nextLine() throws IOException
		{
			return br.readLine();
		}

		public double nextDouble() throws IOException
		{
			String x = next();
			StringBuilder sb = new StringBuilder("0");
			double res = 0, f = 1;
			boolean dec = false, neg = false;
			int start = 0;
			if (x.charAt(0) == '-')
			{
				neg = true;
				start++;
			}
			for (int i = start; i < x.length(); i++)
				if (x.charAt(i) == '.')
				{
					res = Long.parseLong(sb.toString());
					sb = new StringBuilder("0");
					dec = true;
				} else
				{
					sb.append(x.charAt(i));
					if (dec)
						f *= 10;
				}
			res += Long.parseLong(sb.toString()) / f;
			return res * (neg ? -1 : 1);
		}

		public boolean ready() throws IOException
		{
			return br.ready();
		}
	}
}

//package codeforces.GoodBye17;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;

public class D
{
	static int mod = (int)1e9+7;
	static Pair[][] memo;
	static int a,b,k, a_b;
	static Pair sum1, pb, pa, sum2;
	public static void main(String[] args) throws IOException
	{
		Scanner sc = new Scanner(System.in);
		PrintWriter pw = new PrintWriter(System.out);

		k = sc.nextInt();
		a = sc.nextInt();
		b = sc.nextInt();
		a_b = sum(a, b);
		memo = new Pair[k+2][k+2];

		Pair one = new Pair(1, 1);
		pa = new Pair(a, a_b);
		pb = new Pair(b, a_b);
		sum1 = new Pair(one, one.subtract(pa));

		Pair one_pa = one.subtract(pa);
		Pair pp1 = new Pair(pa, one_pa);
		Pair pp2 = new Pair(one, one_pa);
		sum2 = pp1.multiply(pp2);
		solve(1, 0);

		Pair p = simplify(solve(1, 0));
		int rp = p.x;
		int rq = p.y;
		System.out.println(mult(rp, inv(rq, mod)));

		pw.flush();
		pw.close();
	}

	private static Pair simplify(Pair P)
	{
		int gcd = gcd(P.x, P.y);
		P.x = mult(P.x, inv(gcd, mod));
		P.y = mult(P.y, inv(gcd, mod));
		return P;
	}

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

	static int sub(int a, int b)
	{
		int ans = a-b;
		ans %= mod;
		if(ans < 0)
			ans += mod;
		return ans;
	}

	private static Pair solve(int cntA, int tot)
	{
		if(memo[cntA][tot] != null)
			return memo[cntA][tot];

		if(tot >= k)
			return memo[cntA][tot] = new Pair(tot, 1);
		if(cntA+tot >= k) // check > or >=
		{
			return memo[cntA][tot] = pb.multiply(new Pair(tot+cntA, 1).multiply(sum1).add(sum2));
		}

		// a
		int num1 = mult(a, solve(cntA+1, tot).x);
		int den1 = mult(a_b, solve(cntA+1, tot).y);
		Pair a1 = new Pair(num1, den1);
		// b
		int num2 = mult(b, solve(cntA, tot+cntA).x);
		int den2 = mult(a_b, solve(cntA, tot+cntA).y);
		Pair a2 = new Pair(num2, den2);

		return memo[cntA][tot] = a1.add(a2);
	}

	static int mult(int a, int b)
	{
		return (int)(1l*a*b % mod);
	}

	static int sum(int a, int b)
	{
		return (a+b) % mod;
	}

	static class Pair
	{
		int x, y;

		public String toString()
		{
			return x +"/" + y;
		}
		public Pair(int x, int y)
		{
			this.x = x;
			this.y = y;
		}

		public Pair(Pair p1, Pair p2)
		{
			this.x = mult(p1.x, inv(p2.x, mod));
			this.y = mult(p1.y, inv(p2.y, mod));
		}

		Pair multiply(Pair p)
		{
			return new Pair(mult(x, p.x),  mult(y, p.y));
		}

		Pair add(Pair p)
		{
			int xy = mult(p.y, y);
			return new Pair(sum(mult(mult(xy, x), inv(y, mod)), mult(mult(p.x, xy), inv(p.y, mod))),  mult(y, p.y));
		}

		Pair subtract(Pair p)
		{
			Pair tmp = new Pair(-p.x, p.y);
			tmp.x %= mod;
			if(tmp.x < 0)
				tmp.x += mod;
			return add(tmp);
		}
	}

	static int inv(long  x , long mod){
		long r, y;
		for(r = 1 , y = mod - 2 ; y != 0 ;x = x * x % mod, y>>=1)
		if ((y & 1) == 1)
		r = r * x % mod;
		return (int)r;
		}

	static class Scanner
	{
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s)
		{
			br = new BufferedReader(new InputStreamReader(s));
		}

		public Scanner(String s) throws FileNotFoundException
		{
			br = new BufferedReader(new FileReader(new File((s))));
		}

		public String next() throws IOException
		{
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

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

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

		public String nextLine() throws IOException
		{
			return br.readLine();
		}

		public double nextDouble() throws IOException
		{
			String x = next();
			StringBuilder sb = new StringBuilder("0");
			double res = 0, f = 1;
			boolean dec = false, neg = false;
			int start = 0;
			if (x.charAt(0) == '-')
			{
				neg = true;
				start++;
			}
			for (int i = start; i < x.length(); i++)
				if (x.charAt(i) == '.')
				{
					res = Long.parseLong(sb.toString());
					sb = new StringBuilder("0");
					dec = true;
				} else
				{
					sb.append(x.charAt(i));
					if (dec)
						f *= 10;
				}
			res += Long.parseLong(sb.toString()) / f;
			return res * (neg ? -1 : 1);
		}

		public boolean ready() throws IOException
		{
			return br.ready();
		}
	}
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author rishus23
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskD solver = new TaskD();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskD {
        static long mod;
        static long k;
        static long a;
        static long b;
        static long ia;
        static long ib;
        static long iab;
        static long[][] dp;

        public void solve(int testNumber, InputReader in, OutputWriter out) {
            mod = (long) (1e9 + 7);
            k = in.nextLong();
            a = in.nextLong();
            b = in.nextLong();
            ia = pow(a, mod - 2);
            ib = pow(b, mod - 2);
            iab = pow(a + b, mod - 2);
            dp = new long[(int) k + 1][(int) k + 1];
            for (long[] arr : dp)
                Arrays.fill(arr, -1);
            out.println(s(1, 0));
        }

        private long s(int sa, int ab) {
            long x = 1L;
            if (sa + ab >= k) {
                return ((x * (a + b) * ib) % mod - 1 + sa + ab);
            }
            if (dp[sa][ab] != -1)
                return dp[sa][ab];
            dp[sa][ab] = ((x * a * s(sa + 1, ab) % mod) * iab + (x * b * s(sa, sa + ab) % mod) * iab) % mod;
            return dp[sa][ab];
        }

        long pow(long t, long p) {
            if (p == 0)
                return 1;
            if (p % 2 == 1)
                return t * pow(t, p - 1) % mod;
            else
                return pow((t * t) % mod, p / 2) % mod;
        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

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

        public void println(long i) {
            writer.println(i);
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public long nextLong() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            long res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Jialin Ouyang (Jialin.Ouyang@gmail.com)
 */
public class Main {
  public static void main(String[] args) {
    InputStream inputStream = System.in;
    OutputStream outputStream = System.out;
    QuickScanner in = new QuickScanner(inputStream);
    QuickWriter out = new QuickWriter(outputStream);
    TaskD solver = new TaskD();
    solver.solve(1, in, out);
    out.close();
  }

  static class TaskD {
    static IntModular MOD = new IntModular();
    int K;
    int a;
    int b;
    int ab;
    int abInv;
    int pa;
    int paInv;
    int pb;
    int pbInv;
    int[][] dpClosed;
    int[][] dpOpened;
    int[] paPow;

    public void solve(int testNumber, QuickScanner in, QuickWriter out) {
      K = in.nextInt();
      a = in.nextInt();
      b = in.nextInt();
      ab = a + b;
      abInv = MOD.inverse(ab);
      pa = MOD.mul(a, abInv);
      paInv = MOD.inverse(pa);
      pb = MOD.mul(b, abInv);
      pbInv = MOD.inverse(pb);
      out.println(MOD.mul(calc(), paInv));
    }

    int calc() {
      dpClosed = new int[K + 1][K + 1];
      dpOpened = new int[K + 1][K + 1];
      paPow = new int[K + 3];
      paPow[0] = 1;
      for (int i = 1; i < paPow.length; ++i) {
        paPow[i] = MOD.mul(paPow[i - 1], pa);
      }
//System.out.println(IntArrayUtils.toDisplay(paPow));
      dpClosed[K][0] = 1;
      for (int k = K; k >= 0; --k) {
        for (int aCnt = 0; aCnt <= K; ++aCnt) {
          int dp = MOD.add(dpOpened[k][aCnt], dpClosed[k][aCnt]);
          if (dp == 0) continue;
          // add a
          if (aCnt != K) {
            dpOpened[k][aCnt + 1] = MOD.add(
                dpOpened[k][aCnt + 1],
                MOD.mul(dp, pa));
          }
          // add b
          if (aCnt > 0 && k >= aCnt) {
            dpClosed[k - aCnt][aCnt] = MOD.add(
                dpClosed[k - aCnt][aCnt],
                MOD.mul(dp, pb));
          }
        }
      }
      int res = 0;
      for (int k = 0; k <= K; ++k)
        for (int aCnt = 0; aCnt <= K; ++aCnt)
          if (dpClosed[k][aCnt] > 0) {
            int dp = dpClosed[k][aCnt];
            if (k == 0) {
              res = MOD.add(res, MOD.mul(dp, K));
            } else if (k < aCnt) {
              res = MOD.add(
                  res,
                  MOD.mul(
                      dp,
                      MOD.add(
                          K + aCnt - k,
                          MOD.mul(pa, pbInv))));
            } else {
              res = MOD.add(
                  res,
                  MOD.mul(
                      dp,
                      MOD.add(
                          MOD.mul(paPow[k - aCnt + 1], K + 1),
                          MOD.mul(paPow[k - aCnt + 2], pbInv))));
            }
          }
      return res;
    }

  }

  static class IntArrayUtils {
    public static void swap(int[] values, int uIdx, int vIdx) {
      if (uIdx == vIdx) return;
      values[uIdx] ^= values[vIdx];
      values[vIdx] ^= values[uIdx];
      values[uIdx] ^= values[vIdx];
    }

  }

  static class QuickScanner {
    private static final int BUFFER_SIZE = 1024;
    private InputStream stream;
    private byte[] buffer;
    private int currentPosition;
    private int numberOfChars;

    public QuickScanner(InputStream stream) {
      this.stream = stream;
      this.buffer = new byte[BUFFER_SIZE];
      this.currentPosition = 0;
      this.numberOfChars = 0;
    }

    public int nextInt() {
      int c = nextNonSpaceChar();
      boolean positive = true;
      if (c == '-') {
        positive = false;
        c = nextChar();
      }
      int res = 0;
      do {
        if (c < '0' || '9' < c) throw new RuntimeException();
        res = res * 10 + (c - '0');
        c = nextChar();
      } while (!isSpaceChar(c));
      return positive ? res : -res;
    }

    public int nextNonSpaceChar() {
      int res = nextChar();
      for (; isSpaceChar(res) || res < 0; res = nextChar()) ;
      return res;
    }

    public int nextChar() {
      if (numberOfChars == -1) {
        throw new RuntimeException();
      }
      if (currentPosition >= numberOfChars) {
        currentPosition = 0;
        try {
          numberOfChars = stream.read(buffer);
        } catch (Exception e) {
          throw new RuntimeException(e);
        }
        if (numberOfChars <= 0) {
          return -1;
        }
      }
      return buffer[currentPosition++];
    }

    public boolean isSpaceChar(int c) {
      return c == ' ' || c == '\t' || isEndOfLineChar(c);
    }

    public boolean isEndOfLineChar(int c) {
      return c == '\n' || c == '\r' || c < 0;
    }

  }

  static class IntModular {
    private static final int MOD = 1000000007;
    public final int mod;
    private final int[] x;

    public IntModular() {
      this(MOD);
    }

    public IntModular(int mod) {
      this.mod = mod;
      this.x = new int[2];
    }

    public int add(int a, int b) {
      return fix(a + b, mod);
    }

    public int mul(int a, int b) {
      return mul(a, b, mod);
    }

    public int inverse(int a) {
      if (extGcd(a, mod, x) != 1) {
        throw new IllegalArgumentException();
      }
      return slightFix(x[0], mod);
    }

    public int extGcd(int a, int b, int[] x) {
      if (b == 0) {
        x[0] = 1;
        x[1] = 0;
        return a;
      }
      int gcd = extGcd(b, a % b, x);
      IntArrayUtils.swap(x, 0, 1);
      x[1] -= a / b * x[0];
      return gcd;
    }

    public static int mul(int a, int b, int mod) {
      return a > 0
          ? (b < mod / a ? a * b : (int) ((long) a * b % mod))
          : 0;
    }

    public static int fix(int a, int mod) {
      a = slightFix(a, mod);
      return 0 <= a && a < mod ? a : slightFix(a % mod, mod);
    }

    private static int slightFix(int a, int mod) {
      return a >= mod
          ? a - mod
          : a < 0 ? a + mod : a;
    }

  }

  static class QuickWriter {
    private final PrintWriter writer;

    public QuickWriter(OutputStream outputStream) {
      this.writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
    }

    public QuickWriter(Writer writer) {
      this.writer = new PrintWriter(writer);
    }

    public void print(Object... objects) {
      for (int i = 0; i < objects.length; ++i) {
        if (i > 0) {
          writer.print(' ');
        }
        writer.print(objects[i]);
      }
    }

    public void println(Object... objects) {
      print(objects);
      writer.println();
    }

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

  }
}

import static java.util.Arrays.*;

import java.util.*;
import java.util.ArrayList;

public class D {

	public D () {
		K = sc.nextInt();
		long PA = sc.nextLong(), PB = sc.nextLong();
		pA = (PA * modInv(PA + PB)) % MOD; pB = (PB * modInv(PA + PB)) % MOD;
		ipB = modInv(pB);
		F = new long [K][K];
		for (long [] f : F) fill(f, -1);

		long res = f(0, 0);
		exit(res);
	}

	int K;
	long pA, pB, ipB;
	long [][] F;

	long f(int j, int n) {
		if (j >= K)
			return j;
		if (n >= K)
			return (j + n + pA * ipB) % MOD;
		if (F[j][n] != -1)
			return F[j][n];
		if (n == 0)
			return F[j][0] = f(j, 1);
		return F[j][n] = (pA * f(j, n+1) + pB * f(j+n, n)) % MOD;
	}

	private static final int MOD = (int) 1e9 + 7;
	private static long [] distinctPrimeDivisors(long N) {
		List<Long> res = new ArrayList<Long>();
		for (long p = 2; p*p <= N; ++p) {
			if (N % p == 0)
				res.add(p);
			while (N % p == 0)
				N /= p;
		}
		if (N > 1)
			res.add(N);
		return pri(res.toArray(new Long[0]));
	}
	private static long fi (int N) {
		long res = N;
		for (long p : distinctPrimeDivisors(N))
			res = res * (p-1) / p;
		return res;
	}
	private static long modInv(long x) { return modInv(x, MOD); }
	private static long modInv(long x, int mod) {
		long res = modPow(x, fi(mod) - 1, mod);
		assert (res * x) % mod == 1 : "gcd(" + x + ", " + mod + ") != 1";
		return res;
	}
	private static long modPow (long b, long e, int mod) {
		if (e == 0) return 1;
		if (b == 0) return 0;
		if (e == 1) return b;
		long res = 1; int s = Long.numberOfTrailingZeros(Long.highestOneBit(e));
		for (int j = s; j >= 0; --j) {
			res = (res * res) % mod;
			if ((e & (1L << j)) != 0)
				res = (res * b) % mod;
		}
		return res;
	}
	private static long [] pri (Long [] A) { return pri(A, new long [A.length]); }
	private static long [] pri (Long [] A, long [] a) { for (int i = 0; i < A.length; ++i) a[i] = A[i]; return a; }
	////////////////////////////////////////////////////////////////////////////////////
	private final static IOUtils.MyScanner sc = new IOUtils.MyScanner();
	private static void exit (Object o, Object ... A) { IOUtils.print(o, A); IOUtils.exit(); }
	private static class IOUtils {
		public static class MyScanner {
			public String next() { newLine(); return line[index++]; }
			public int nextInt() { return Integer.parseInt(next()); }
			public long nextLong() { return Long.parseLong(next()); }
			//////////////////////////////////////////////
			private boolean eol() { return index == line.length; }
			private String readLine() {
				try {
					return r.readLine();
				} catch (Exception e) {
					throw new Error (e);
				}
			}
			private final java.io.BufferedReader r;
			private MyScanner () { this(new java.io.BufferedReader(new java.io.InputStreamReader(System.in))); }
			private MyScanner (java.io.BufferedReader r) {
				try {
					this.r = r;
					while (!r.ready())
						Thread.sleep(1);
					start();
				} catch (Exception e) {
					throw new Error(e);
				}
			}
			private String [] line;
			private int index;
			private void newLine() {
				if (line == null || eol()) {
					line = split(readLine());
					index = 0;
				}
			}
			private String [] split(String s) { return s.length() > 0 ? s.split(" ") : new String [0]; }
		}
		private static String build(Object o, Object ... A) { return buildDelim(" ", o, A); }
		private static String buildDelim(String delim, Object o, Object ... A) {
			StringBuilder b = new StringBuilder();
			append(b, o, delim);
			for (Object p : A)
				append(b, p, delim);
			return b.substring(delim.length());
		}
		//////////////////////////////////////////////////////////////////////////////////
		private static void start() { if (t == 0) t = millis(); }
		private static void append(StringBuilder b, Object o, String delim) {
			if (o.getClass().isArray()) {
				int len = java.lang.reflect.Array.getLength(o);
				for (int i = 0; i < len; ++i)
					append(b, java.lang.reflect.Array.get(o, i), delim);
			} else if (o instanceof Iterable<?>)
				for (Object p : (Iterable<?>) o)
					append(b, p, delim);
			else {
				if (o instanceof Double)
					o = new java.text.DecimalFormat("#.############").format(o);
				b.append(delim).append(o);
			}
		}
		private static java.io.PrintWriter pw = new java.io.PrintWriter(System.out);
		private static void print(Object o, Object ... A) { pw.println(build(o, A)); }
		private static void err(Object o, Object ... A) { System.err.println(build(o, A)); }
		private static void exit() {
			IOUtils.pw.close();
			System.out.flush();
			err("------------------");
			err(IOUtils.time());
			System.exit(0);
		}
		private static long t;
		private static long millis() { return System.currentTimeMillis(); }
		private static String time() { return "Time: " + (millis() - t) / 1000.0; }
	}
	public static void main (String[] args) { new D(); IOUtils.exit(); }
}

import java.io.*;
import java.util.*;

public class MainD {
	static StdIn in = new StdIn();
	static PrintWriter out = new PrintWriter(System.out);
	static final long M=(long)1e9+7;
	static long[][] dp = new long[2000][2000];
	static long pa, pb;
	static int k;

	public static void main(String[] args) {
		for(int i=0; i<2000; ++i)
			Arrays.fill(dp[i], -1);
		k=in.nextInt();
		pa=in.nextLong();
		pb=in.nextLong();
		pa=pa*modI(pa+pb, M)%M;
		pb=M+1-pa;
		out.println(E(1, 0));
		out.close();
	}

	static long E(int i, int j) {
		if(i+j>=k)
			return (i+j+pa*modI(pb, M))%M;
		if(dp[i][j]!=-1)
			return dp[i][j];
		dp[i][j]=(pa*E(i+1, j)+pb*E(i, j+i))%M;
		return dp[i][j];
	}

	static long expM(long b, long p, long m) {
        if(p==0)
			return 1;
        if(p==1)
			return b%m;
        long r = expM(b, p>>1, m);
        if((p&1)==0)
			return r*r%m;
        return r*r%m*b%m;
    }

	static long modI(long a, long m) {
        long m0 = m, t, q, x0 = 0, x1 = 1;
        while(a>1) {
            q = a / m;
            t = m;
            m = a % m;
            a = t;
            t = x0;
            x0 = x1 - q * x0;
            x1 = t;
        }
        if(x1<0)
			x1 += m0;
        return x1;
    }

	interface Input {
		public String next();
		public String nextLine();
		public int nextInt();
		public long nextLong();
		public double nextDouble();
	}
	static class StdIn implements Input {
		final private int BUFFER_SIZE = 1 << 16;
		private DataInputStream din;
		private byte[] buffer;
		private int bufferPointer, bytesRead;
		public StdIn() {
			din = new DataInputStream(System.in);
			buffer = new byte[BUFFER_SIZE];
			bufferPointer = bytesRead = 0;
		}
		public StdIn(InputStream in) {
			try{
				din = new DataInputStream(in);
			} catch(Exception e) {
				throw new RuntimeException();
			}
			buffer = new byte[BUFFER_SIZE];
			bufferPointer = bytesRead = 0;
		}
		public String next() {
			int c;
			while((c=read())!=-1&&(c==' '||c=='\n'||c=='\r'));
			StringBuilder s = new StringBuilder();
			while (c != -1)
			{
				if (c == ' ' || c == '\n'||c=='\r')
					break;
				s.append((char)c);
				c=read();
			}
			return s.toString();
		}
		public String nextLine() {
			int c;
			while((c=read())!=-1&&(c==' '||c=='\n'||c=='\r'));
			StringBuilder s = new StringBuilder();
			while (c != -1)
			{
				if (c == '\n'||c=='\r')
					break;
				s.append((char)c);
				c = read();
			}
			return s.toString();
		}
		public int nextInt() {
			int ret = 0;
			byte c = read();
			while (c <= ' ')
				c = read();
			boolean neg = (c == '-');
			if (neg)
				c = read();
			do
				ret = ret * 10 + c - '0';
			while ((c = read()) >= '0' && c <= '9');

			if (neg)
				return -ret;
			return ret;
		}
		public int[] readIntArray(int n) {
			int[] ar = new int[n];
			for(int i=0; i<n; ++i)
				ar[i]=nextInt();
			return ar;
		}
		public long nextLong() {
			long ret = 0;
			byte c = read();
			while (c <= ' ')
				c = read();
			boolean neg = (c == '-');
			if (neg)
				c = read();
			do
				ret = ret * 10 + c - '0';
			while ((c = read()) >= '0' && c <= '9');
			if (neg)
				return -ret;
			return ret;
		}
		public long[] readLongArray(int n) {
			long[] ar = new long[n];
			for(int i=0; i<n; ++i)
				ar[i]=nextLong();
			return ar;
		}
		public double nextDouble() {
			double ret = 0, div = 1;
			byte c = read();
			while (c <= ' ')
				c = read();
			boolean neg = (c == '-');
			if (neg)
				c = read();
			do
				ret = ret * 10 + c - '0';
			while ((c = read()) >= '0' && c <= '9');
			if (c == '.')
				while ((c = read()) >= '0' && c <= '9')
					ret += (c - '0') / (div *= 10);
			if (neg)
				return -ret;
			return ret;
		}
		private void fillBuffer() throws IOException {
			bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
			if (bytesRead == -1)
				buffer[0] = -1;
		}
		private byte read() {
			try{
				if (bufferPointer == bytesRead)
					fillBuffer();
				return buffer[bufferPointer++];
			} catch(IOException e) {
				throw new RuntimeException();
			}
		}
		public void close() throws IOException {
			if (din == null)
				return;
			din.close();
		}
	}
}

import java.io.*;
import java.util.*;
public class newyear {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskE solver = new TaskE();
        solver.solve(1, in, out);
        out.flush();out.close();
    }
        static class TaskE {
        class pair{
        	int n,v;pair(int a,int b){n=a;v=b;}
        }
        long rec(int na,int nc,int k,int L) {
        	//if(nc>=k)return cal(nc);
        	if(na+nc>=k)return (pb*cal(na+nc))%mod;
        	if(dp[na][nc]!=0)return dp[na][nc];
        	dp[na][nc]=((pb*rec(na,na+nc,k,L+1))%mod+(pa*rec(na+1,nc,k,L+1))%mod)%mod;
    		return dp[na][nc];
        }
        long cal(long x) {
        	return ((x*C)%mod+((pa*C)%mod*C)%mod)%mod;
        }
        long rpe(long a,long b) {
        	long r=1;
        	while(b!=0) {
        		if(b%2!=0)r=(r*a)%mod;
        		a=(a*a)%mod;b/=2;
        	}return r;
        }
        long dp[][],mod=(long)(1E9)+7,pa,pb,C;
         public void solve(int testNumber, InputReader in, PrintWriter out) {
          int k=in.nextInt();pa=in.nextLong();pb=in.nextLong();
          long I=rpe(pa+pb,mod-2);pa=(pa*I)%mod;pb=(pb*I)%mod;
          dp=new long[1001][1001];
          long m=rpe(1-pb+mod,mod-2);C=rpe(1-pa+mod,mod-2);//System.out.println(m);
          out.print(((pa*rec(1,0,k,1))%mod*m)%mod);
          //out.print(2*rpe(3,mod-2)+" "+8*rpe(12,mod-2));
         }
    }
    static class InputReader {
        BufferedReader br;
        StringTokenizer st;
        public InputReader(InputStream stream) {
            br = new BufferedReader(new InputStreamReader(stream));
            st = null;
        }

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

        boolean hasMoreTokens() {
            while (st == null || !st.hasMoreTokens()) {
                String s = null;
                try {
                    s = br.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (s == null)
                    return false;
                st = new StringTokenizer(s);
            }
            return true;
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }
        public long nextLong() {
            return Long.parseLong(next());
        }
        public double nextDouble() {
            return Double.parseDouble(next());
        }
    }
}

import java.io.*;
import java.math.BigInteger;
import java.util.*;

public class A {
    private FastScanner in;
    private PrintWriter out;

    void solve() {
        int k = in.nextInt();
        long pa = in.nextInt();
        long pb = in.nextInt();
        final int mod = (int) 1e9 + 7;
        BigInteger MOD = BigInteger.valueOf(mod);
        int inv = BigInteger.valueOf(pa + pb).modInverse(MOD).intValue();
        pa = (int) ((pa * 1L * inv) % mod);
        pb = (int) ((pb * 1L * inv) % mod);
        long[][] dp = new long[k + 1][k];
        dp[1][0] = 1;
        long res = 0;
        long sInv = BigInteger.valueOf((mod - pa + 1) % mod).modInverse(MOD).intValue();
        for (int cntA = 0; cntA <= k; cntA++) {
            for (int curK = 0; curK < k; curK++) {
                long pr = dp[cntA][curK];
                if (pr == 0) {
                    continue;
                }
                if (cntA != k) {
                    dp[cntA + 1][curK] = (int) ((dp[cntA + 1][curK] + pr * pa) % mod);
                } else {
                    long tmpPR = (int) (pr * pa % mod);
                    res += tmpPR * curK % mod;
                    tmpPR = (int) (tmpPR * pb % mod);
                    res += cntA *sInv % mod * tmpPR % mod;
                    res += sInv * sInv % mod * tmpPR % mod;
                    res %= mod;
                }
                if (curK + cntA >= k) {
                    res = (res + pr * pb % mod * (curK + cntA)) % mod;
//                    System.err.println("add " + res);
                } else {
                    dp[cntA][curK + cntA] = ((dp[cntA][curK + cntA] + pr * pb) % mod);
                }
            }
        }
        out.println(res % mod);
    }

    private void run() {
        try {
            in = new FastScanner(new File("A.in"));
            out = new PrintWriter(new File("A.out"));

            solve();

            out.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }

    private void runIO() {
        in = new FastScanner(System.in);
        out = new PrintWriter(System.out);

        solve();

        out.close();
    }

    private class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        FastScanner(File f) {
            try {
                br = new BufferedReader(new FileReader(f));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }

        FastScanner(InputStream f) {
            br = new BufferedReader(new InputStreamReader(f));
        }

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

        boolean hasMoreTokens() {
            while (st == null || !st.hasMoreTokens()) {
                String s = null;
                try {
                    s = br.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (s == null)
                    return false;
                st = new StringTokenizer(s);
            }
            return true;
        }

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

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

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

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

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author ilyakor
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskD solver = new TaskD();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskD {
        static final int mod = 1000 * 1000 * 1000 + 7;
        int k;
        int pa;
        int pb;
        int[][] d;

        public void solve(int testNumber, InputReader in, OutputWriter out) {
            k = in.nextInt();
            pa = in.nextInt();
            pb = in.nextInt();
            int papb;
            {
                int den = IntegerUtils.pow(pa + pb, mod - 2, mod);
                pa = (int) (((long) pa * (long) den) % mod);
                pb = (int) (((long) pb * (long) den) % mod);
                papb = (int) ((pa * (long) IntegerUtils.pow(pb, mod - 2, mod)) % mod);
            }

            d = new int[k + 1][k];
            d[1][0] = 1;
            long res = 0;
            for (int x = 1; x <= k; ++x) {
                for (int cnt = 0; cnt < k; ++cnt) {
                    int cur = d[x][cnt];
                    if (cur == 0) continue;
                    if (x < k) {
                        int prob = (int) (((long) pa * (long) cur) % mod);
                        long sum = 0;
                        for (int nb = 0; ; ++nb) {
                            int ncnt = cnt + nb * x;
                            if (ncnt >= k) {
                                long val = cur - sum;
                                if (val < 0) val += mod;
                                res += val * (long) ncnt;
                                res %= mod;
                                break;
                            } else {
                                d[x + 1][ncnt] = (d[x + 1][ncnt] + prob) % mod;
                                sum += prob;
                                prob = (int) ((prob * (long) pb) % mod);
                            }
                        }
                    } else {
                        int val = cnt + k + papb;
                        val %= mod;
                        res += val * (long) cur;
                        res %= mod;
                    }
                }
            }
            out.printLine(res);
        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void print(Object... objects) {
            for (int i = 0; i < objects.length; i++) {
                if (i != 0) {
                    writer.print(' ');
                }
                writer.print(objects[i]);
            }
        }

        public void printLine(Object... objects) {
            print(objects);
            writer.println();
        }

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

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buffer = new byte[10000];
        private int cur;
        private int count;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public static boolean isSpace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public int read() {
            if (count == -1) {
                throw new InputMismatchException();
            }
            try {
                if (cur >= count) {
                    cur = 0;
                    count = stream.read(buffer);
                    if (count <= 0)
                        return -1;
                }
            } catch (IOException e) {
                throw new InputMismatchException();
            }
            return buffer[cur++];
        }

        public int readSkipSpace() {
            int c;
            do {
                c = read();
            } while (isSpace(c));
            return c;
        }

        public int nextInt() {
            int sgn = 1;
            int c = readSkipSpace();
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res = res * 10 + c - '0';
                c = read();
            } while (!isSpace(c));
            res *= sgn;
            return res;
        }

    }

    static class IntegerUtils {
        public static int pow(long x, long y, int mod) {
            x %= mod;
            long res = 1;
            while (y > 0) {
                if (y % 2 == 1) {
                    --y;
                    res = (res * x) % mod;
                } else {
                    y /= 2;
                    x = (x * x) % mod;
                }
            }
            return (int) (res % mod);
        }

    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.FileNotFoundException;
import java.util.StringTokenizer;
import java.io.Writer;
import java.io.BufferedReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Asgar Javadov
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        FastWriter out = new FastWriter(outputStream);
        TaskD solver = new TaskD();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskD {
        int[][] state;
        int pa;
        int pb;
        int ipa;
        int ipb;

        public void solve(int testNumber, InputReader in, FastWriter out) {
            int k = in.nextInt();
            int a = in.nextInt();
            int b = in.nextInt();

            state = new int[k][k];

            int inv = NumberTheory.inv(a + b);
            pa = NumberTheory.multiply(a, inv);
            pb = NumberTheory.multiply(b, inv);
            ipa = NumberTheory.inv(pa);
            ipb = NumberTheory.inv(pb);

            out.println(rec(1, 0, k));
        }

        private int rec(int i, int j, int k) {
            if (i + j >= k) {
                return NumberTheory.add(i + j, NumberTheory.multiply(pa, ipb));
            } else if (state[i][j] > 0) {
                return state[i][j];
            } else {
                state[i][j] = NumberTheory.add(NumberTheory.multiply(pa, rec(i + 1, j, k)), NumberTheory.multiply(pb, rec(i, i + j, k)));
                return state[i][j];
            }
        }

    }

    static class NumberTheory {
        public static final int MODULO = 1_000_000_007;

        public static int multiply(int a, int b) {
            long product = a * (long) b;
            if (product >= MODULO)
                product %= MODULO;
            return (int) product;
        }

        public static int add(int a, int b) {
            long sum = a + (long) b;
            if (sum >= MODULO)
                sum -= MODULO;
            return (int) sum;
        }

        public static int pow(int a, long n, int mod) {
            long res = 1L;
            long half = a;
            while (n != 0) {
                if ((n & 1) == 1)
                    res = res * half % mod;
                half = half * half % mod;
                n >>= 1;
            }
            return (int) res;
        }

        public static int inv(int a) {
            return pow(a, MODULO - 2, MODULO);
        }

    }

    static 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());
        }

    }

    static class FastWriter extends PrintWriter {
        public FastWriter(OutputStream outputStream) {
            super(outputStream);
        }

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

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

    }
}

import java.util.*;
import java.io.*;

public class Problem
{

    static int mod = (int) (1e9+7);
    static InputReader in;
    static PrintWriter out;
    static long pa;
    static long pb;
    static long[][] dp;
    static long pinv;
    static long pabypb;
    static int k;

    static long solve(int a, int ab){
        if(ab >= k)
            return ab;
        if(a >= k)
            return (a + ab + pabypb) % mod;
        if(dp[a][ab] != -1)
            return dp[a][ab];
        long ans = solve(a + 1, ab) * pa;
        ans %= mod;
        ans = (ans + (solve(a, ab + a) * pb) % mod) % mod;
        return dp[a][ab] = ans;
    }

    static void solve()
    {
        in = new InputReader(System.in);
        out = new PrintWriter(System.out);

        k = in.nextInt();
        pa = in.nextInt();
        pb = in.nextInt();
        pinv = pow(pa + pb, mod - 2, mod);
        pa = (pa * pinv) % mod;
        pb = (pb * pinv) % mod;
        pabypb = (pa * pow(pb, mod - 2, mod)) % mod;
        dp = new long[k + 1][k + 1];

        for(int i = 0; i <= k; i++)
            Arrays.fill(dp[i], -1);

        out.println(solve(1, 0));
        out.close();
    }

    public static void main(String[] args)
    {
        new Thread(null ,new Runnable(){
            public void run(){
                try{
                    solve();
                } catch(Exception e){
                    e.printStackTrace();
                }
            }
        },"1",1<<26).start();

    }

    static class Pair implements Comparable<Pair>
    {

        int x;
        long y;
        int i;

        Pair (int x,long y)
        {
                this.x = x;
                this.y = y;
        }

        Pair (int x,int y, int i)
        {
                this.x = x;
                this.y = y;
                this.i = i;
        }

        public int compareTo(Pair o)
        {
            return Long.compare(this.y,o.y);
                //return 0;
        }

        public boolean equals(Object o)
        {
            if (o instanceof Pair)
            {
                Pair p = (Pair)o;
                return p.x == x && p.y==y;
            }
            return false;
        }

        @Override
        public String toString()
        {
            return x + " "+ y + " "+i;
        }

        /*public int hashCode()
        {
            return new Long(x).hashCode() * 31 + new Long(y).hashCode();
        }*/

    }

    static long add(long a,long b){
        long x=(a+b);
        while(x>=mod) x-=mod;
        return x;
    }

    static long sub(long a,long b){
        long x=(a-b);
        while(x<0) x+=mod;
        return x;
    }

    static long mul(long a,long b){
        long x=(a*b);
        while(x>=mod) x-=mod;
        return x;
    }

    static String rev(String s){
        StringBuilder sb=new StringBuilder(s);
        sb.reverse();
        return sb.toString();
    }

    static long gcd(long x,long y)
    {
        if(y==0)
                return x;
        else
                return gcd(y,x%y);
    }

    static int gcd(int x,int y)
    {
        if(y==0)
                return x;
        else
                return gcd(y,x%y);
    }

    static long pow(long n,long p,long m)
    {
         long  result = 1;
          if(p==0){
            return n;
          }

        while(p!=0)
        {
            if(p%2==1)
                result *= n;
            if(result >= m)
               result %= m;
            p >>=1;
            n*=n;
            if(n >= m)
                n%=m;
        }

        return result;
    }

    static long pow(long n,long p)
    {
        long  result = 1;
          if(p==0)
            return 1;

        while(p!=0)
        {
            if(p%2==1)
                result *= n;
            p >>=1;
            n*=n;
        }
        return result;
    }

    static void debug(Object... o)
    {
            System.out.println(Arrays.deepToString(o));
    }

    static class InputReader
    {

        private final InputStream stream;
        private final byte[] buf = new byte[8192];
        private int curChar, snumChars;
        private SpaceCharFilter filter;

        public InputReader(InputStream stream)
        {
                this.stream = stream;
        }

        public int snext()
        {
                if (snumChars == -1)
                        throw new InputMismatchException();
                if (curChar >= snumChars)
                {
                        curChar = 0;
                        try
                        {
                                snumChars = stream.read(buf);
                        } catch (IOException e)
                        {
                                throw new InputMismatchException();
                        }
                        if (snumChars <= 0)
                                return -1;
                }
                return buf[curChar++];
        }

        public int nextInt()
        {
                int c = snext();
                while (isSpaceChar(c))
                {
                        c = snext();
                }
                int sgn = 1;
                if (c == '-')
                {
                        sgn = -1;
                        c = snext();
                }
                int res = 0;
                do
                {
                        if (c < '0' || c > '9')
                                throw new InputMismatchException();
                        res *= 10;
                        res += c - '0';
                        c = snext();
                } while (!isSpaceChar(c));
                return res * sgn;
        }

        public long nextLong()
        {
                int c = snext();
                while (isSpaceChar(c))
                {
                        c = snext();
                }
                int sgn = 1;
                if (c == '-')
                {
                        sgn = -1;
                        c = snext();
                }
                long res = 0;
                do
                {
                        if (c < '0' || c > '9')
                                throw new InputMismatchException();
                        res *= 10;
                        res += c - '0';
                        c = snext();
                } while (!isSpaceChar(c));
                return res * sgn;
        }

        public int[] nextIntArray(int n)
        {
                int a[] = new int[n];
                for (int i = 0; i < n; i++)
                {
                        a[i] = nextInt();
                }
                return a;
        }

        public long[] nextLongArray(int n)
        {
                long a[] = new long[n];
                for (int i = 0; i < n; i++)
                {
                        a[i] = nextLong();
                }
                return a;
        }

        public String readString()
        {
                int c = snext();
                while (isSpaceChar(c))
                {
                        c = snext();
                }
                StringBuilder res = new StringBuilder();
                do
                {
                        res.appendCodePoint(c);
                        c = snext();
                } while (!isSpaceChar(c));
                return res.toString();
        }

        public String nextLine()
        {
                int c = snext();
                while (isSpaceChar(c))
                        c = snext();
                StringBuilder res = new StringBuilder();
                do
                {
                        res.appendCodePoint(c);
                        c = snext();
                } while (!isEndOfLine(c));
                return res.toString();
        }

        public boolean isSpaceChar(int c)
        {
                if (filter != null)
                        return filter.isSpaceChar(c);
                return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        private boolean isEndOfLine(int c)
        {
                return c == '\n' || c == '\r' || c == -1;
        }

        public interface SpaceCharFilter
        {
                public boolean isSpaceChar(int ch);
        }

    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Scanner;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author ZYCSwing
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskD solver = new TaskD();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskD {
        private static final int MOD = (int) 1e9 + 7;
        private static final int N = 1010;
        long[][] dp;
        long k;
        long a;
        long b;
        long pa;
        long pb;

        long power(long base, int exp) {
            long res = 1;
            while (exp > 0) {
                if ((exp & 1) != 0) {
                    res *= base;
                    res %= MOD;
                }
                base = base * base % MOD;
                exp >>= 1;
            }
            return res;
        }

        long inv(long x) {
            return power(x, MOD - 2);
        }

        long DP(int a, int ab) {
            if (ab >= k) {
                return ab;
            } else if (a + ab >= k) {
                return (a + ab + pa * inv(pb)) % MOD;
            }
            if (dp[a][ab] >= 0) return dp[a][ab];
            return dp[a][ab] = (pa * DP(a + 1, ab) % MOD + pb * DP(a, a + ab) % MOD) % MOD;
        }

        public void solve(int testNumber, Scanner in, PrintWriter out) {
            k = in.nextLong();
            a = in.nextLong();
            b = in.nextLong();
            pa = a * inv(a + b) % MOD;
            pb = b * inv(a + b) % MOD;

            dp = new long[N][N];
            for (int i = 0; i < N; ++i) {
                Arrays.fill(dp[i], -1);
            }

            out.println(DP(1, 0));
        }

    }
}

//Why is this a DP problem?
//1. Easy to get from one case to next: each b adds #(a) subsequences of ab.
//2. Math problem w/ no direct way to compute, e.g. NOIP 2013, 900D. But if we know the #ab, #a, it's super easy.
//2.1. In particular, if I can't find an explicit formula, try DP b/c I'm good at math.
import java.util.*;

public class TaskD
{
    private static long P = (long) 1e9+7;

    public static long inverse (long a)
    {
        long m = P, t, q;
        long x0 = 0, x1 = 1;

        while (a > 1)
        {
            q = a / m;
            t = m;
            // process same as Euclid's algo
            m = a % m; a = t;
            t = x0;
            x0 = x1 - q * x0;
            x1 = t;
        }
        // Make x1 positive
        if (x1 < 0) x1 += P;
        return x1;
    }

    public static void main(String[] args) {
        Scanner f = new Scanner(System.in);
        int k = f.nextInt();
        long pa = f.nextInt(), pb = f.nextInt(), ipb = inverse(pb), ipab = inverse(pa+pb);
        long[][] e = new long[2*k][2*k];
        for (int i = 2*k-1; i >= 1; i--){
            for (int j = 2*k-1; j >= 0; j--) {
                if (i + j >= k) e[i][j] = (i + j + pa * ipb) % P;
                else e[i][j] = ((pa * e[i+1][j] % P + pb * e[i][i+j]% P) * ipab) % P;
            }
        }
        System.out.println(e[1][0]);
    }
}

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

/**
 * @author Don Li
 */
public class NewYearArbitraryArrangement2 {

    int MOD = (int) 1e9 + 7;

    void solve() {
        int k = in.nextInt();
        int a = in.nextInt(), b = in.nextInt();

        long pa = a * inv(a + b) % MOD;
        long pb = b * inv(a + b) % MOD;
        long x = pa * inv(pb) % MOD;

        long[][] dp = new long[k + 1][k + 1];
        dp[0][1] = 1;

        long ans = 0;
        for (int i = 0; i <= k; i++) {
            for (int j = 0; j <= k; j++) {
                if (i + j >= k) {
                    long e = i + j + x;
                    ans = (ans + dp[i][j] * e % MOD) % MOD;
                    continue;
                }
                dp[i][j + 1] = (dp[i][j + 1] + dp[i][j] * pa % MOD) % MOD;
                dp[i + j][j] = (dp[i + j][j] + dp[i][j] * pb % MOD) % MOD;
            }
        }
        out.println(ans);
    }

    long inv(long x) {
        if (x == 1) return 1;
        return (MOD - MOD / x) * inv(MOD % x) % MOD;
    }

    public static void main(String[] args) {
        in = new FastScanner(new BufferedReader(new InputStreamReader(System.in)));
        out = new PrintWriter(System.out);
        new NewYearArbitraryArrangement2().solve();
        out.close();
    }

    static FastScanner in;
    static PrintWriter out;

    static class FastScanner {
        BufferedReader in;
        StringTokenizer st;

        public FastScanner(BufferedReader in) {
            this.in = in;
        }

        public String nextToken() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(in.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

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

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

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Junior
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskD solver = new TaskD();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskD {
        long MOD = (int) 1e9 + 7;
        int k;
        int a;
        int b;
        int ia;
        int ib;
        int iab;
        int pa;
        int pb;
        long[][] dp;

        public void solve(int testNumber, InputReader in, OutputWriter out) {
            k = in.nextInt();
            a = in.nextInt();
            b = in.nextInt();
            ia = (int) MathUtils.invMod(a, MOD);
            ib = (int) MathUtils.invMod(b, MOD);
            iab = (int) MathUtils.invMod(MathUtils.addMod(a, b, MOD), MOD);
            dp = new long[k + 1][k + 1];
            pa = (int) MathUtils.mulMod(a, iab, MOD);
            pb = (int) MathUtils.mulMod(b, iab, MOD);
            for (int i = 0; i < k; ++i) dp[k][i] = (1l * i + k + a * ib) % MOD;
            for (int i = k - 1; i >= 1; --i) {
                for (int j = k - 1; j >= 0; --j) {
                    dp[i][j] = ((1l * pa * dp[i + 1][j]) + (1l * pb * ((i + j >= k) ? i + j : dp[i][i + j]))) % MOD;
                }
            }
            out.println(dp[1][0]);
        }

    }

    static class MathUtils {
        public static long addMod(long a, long b, long md) {
            return (a + b) % md;
        }

        public static long mulMod(long a, long b, long md) {
            return (a * b) % md;
        }

        public static long powMod(long b, long p, long md) {
            long ans = 1;
            while (p > 0) {
                if ((p & 1) > 0) ans = mulMod(ans, b, md);
                p >>= 1;
                b = mulMod(b, b, md);
            }
            return ans;
        }

        public static long invMod(long x, long p) { //only if p is prime
            return powMod(x, p - 2, p);
        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

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

        public void println(long i) {
            writer.println(i);
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int nextInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Junior
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskD solver = new TaskD();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskD {
        int k;
        int pa;
        int pb;
        int papb;
        int npa;
        int npb;
        int MOD = (int) 1e9 + 7;
        int ipb;
        int[][] pd;

        int func(int ca, int qtd) {
            if (qtd >= k) return qtd;
            if (ca >= k) return (int) ((1l * qtd + ca + ipb - 1l + MOD) % MOD);
            if (pd[ca][qtd] != -1) return pd[ca][qtd];
            int a = (int) MathUtils.mulMod(npa, func(ca + 1, qtd), MOD);
            int b = (int) MathUtils.mulMod(npb, func(ca, qtd + ca), MOD);
            return pd[qtd][ca] = (int) MathUtils.addMod(a, b, MOD);
        }

        public void solve(int testNumber, InputReader in, OutputWriter out) {
            k = in.nextInt();
            pa = in.nextInt();
            pb = in.nextInt();
            papb = (int) MathUtils.invMod(MathUtils.addMod(pa, pb, MOD), MOD);
            npa = (int) MathUtils.mulMod(pa, papb, MOD);
            npb = (int) MathUtils.mulMod(pb, papb, MOD);
            ipb = (int) MathUtils.invMod(npb, MOD);
            pd = new int[k + 1][k + 1];
            for (int i = 0; i <= k; ++i) for (int j = 0; j <= k; ++j) pd[i][j] = -1;
            out.println(func(1, 0));
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int nextInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }

    static class MathUtils {
        public static long addMod(long a, long b, long md) {
            return (a + b) % md;
        }

        public static long mulMod(long a, long b, long md) {
            return (a * b) % md;
        }

        public static long powMod(long b, long p, long md) {
            long ans = 1;
            while (p > 0) {
                if ((p & 1) > 0) ans = mulMod(ans, b, md);
                p >>= 1;
                b = mulMod(b, b, md);
            }
            return ans;
        }

        public static long invMod(long x, long p) { //only if p is prime
            return powMod(x, p - 2, p);
        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

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

        public void println(int i) {
            writer.println(i);
        }

    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Junior
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskD solver = new TaskD();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskD {
        int k;
        int pa;
        int pb;
        int papb;
        int npa;
        int npb;
        int MOD = (int) 1e9 + 7;
        int ipb;
        int[][] pd;

        int func(int ca, int qtd) {
            if (qtd >= k) return qtd;
            if (ca >= k) {
                int s = (int) MathUtils.addMod(ca, qtd, MOD);
                return (int) MathUtils.addMod(s, ipb, MOD);
            }
            if (pd[ca][qtd] != -1) return pd[ca][qtd];
            int a = (int) MathUtils.mulMod(npa, func(ca + 1, qtd), MOD);
            int b = (int) MathUtils.mulMod(npb, func(ca, qtd + ca), MOD);
            return pd[qtd][ca] = (int) MathUtils.addMod(a, b, MOD);
        }

        public void solve(int testNumber, InputReader in, OutputWriter out) {
            k = in.nextInt();
            pa = in.nextInt();
            pb = in.nextInt();
            papb = (int) MathUtils.invMod(MathUtils.addMod(pa, pb, MOD), MOD);
            npa = (int) MathUtils.mulMod(pa, papb, MOD);
            npb = (int) MathUtils.mulMod(pb, papb, MOD);
            ipb = (int) MathUtils.invMod(npb, MOD);
            ipb = (int) MathUtils.addMod(ipb, MOD - 1, MOD);
            pd = new int[k + 1][k + 1];
            for (int i = 0; i <= k; ++i) for (int j = 0; j <= k; ++j) pd[i][j] = -1;
            out.println(func(1, 0));
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int nextInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }

    static class MathUtils {
        public static long addMod(long a, long b, long md) {
            return (a + b) % md;
        }

        public static long mulMod(long a, long b, long md) {
            return (a * b) % md;
        }

        public static long powMod(long b, long p, long md) {
            long ans = 1;
            while (p > 0) {
                if ((p & 1) > 0) ans = mulMod(ans, b, md);
                p >>= 1;
                b = mulMod(b, b, md);
            }
            return ans;
        }

        public static long invMod(long x, long p) { //only if p is prime
            return powMod(x, p - 2, p);
        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

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

        public void println(int i) {
            writer.println(i);
        }

    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

public class d {

	static long k, dp[][], rpa, rpb, mod;
	static BigInteger bmod = BigInteger.valueOf((long) 1e9 + 7);
	static long go(int as, int seq) {
		if(seq >= k) return seq;
		if(as + seq >= k) {
			return (BigInteger.valueOf(rpb).modInverse(bmod).longValue() - 1 + as + seq) % mod;
		}
		if(dp[seq][as] != -1) return dp[as][seq];
		return dp[seq][as] = (((go(as+1, seq) * rpa) % mod) +  (go(as, seq+as) * rpb) % mod) % mod;
	}

	public static void main(String args[]) throws IOException {
		FastScanner in = new FastScanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		//BEGIN HERE
		mod = (long) 1e9 + 7;
		k = in.nextLong();
		long pa = in.nextLong();
		long pb = in.nextLong();

		rpa = pa * BigInteger.valueOf(pa+pb).modInverse(BigInteger.valueOf(mod)).longValue();
		rpb = pb * BigInteger.valueOf(pa+pb).modInverse(BigInteger.valueOf(mod)).longValue();
		rpa %= mod;
		rpb %= mod;
		dp = new long [(int) (k+1)][(int) (k+1)];
		for(int i = 0; i <= k; i++)
			Arrays.fill(dp[i], -1);

		System.out.println(go(1,0));
		out.close();
	}

	static class FastScanner {
		BufferedReader br;
		StringTokenizer st;

		public FastScanner(InputStream i) {
			br = new BufferedReader(new InputStreamReader(i));
			st = null;
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public String nextLine() throws IOException {
			if (st == null) {
				st = new StringTokenizer(br.readLine());
			}
			String line = st.nextToken("\n");
			st = null;
			return line;
		}

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

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

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

	public static class combinatorics {
		static long modInv(long a, long b) {
			return 1 < a ? b - modInv(b % a, a) * b / a : 1;
		}

		static long factorial[], mod;

		combinatorics(int n, long MOD) {
			mod = MOD;
			factorial = new long[n + 1];
			factorial[0] = 1;
			for (int i = 1; i <= n; i++) {
				factorial[i] = i * factorial[i - 1];
				factorial[i] %= mod;
			}
		}

		static long nCr(int n, int r) {
			if (r > n)
				return 0;
			return (factorial[n] * modInv((factorial[n - r] * factorial[r]) % mod, mod)) % mod;
		}

		static long gcd(long a, long b) {
			return b == 0 ? a : gcd(b, a % b);
		}

		static long lcm(long a, long b) {
			return a * (b / gcd(a, b));
		}
	}

	public static class DisjointSet {
		int p[], r[], s[];
		int numDisjoint;

		DisjointSet(int N) {
			numDisjoint = N;
			r = new int[N];
			s = new int[N];
			p = new int[N];
			for (int i = 0; i < N; i++)
				p[i] = i;
		}

		int findSet(int i) {
			return (p[i] == i) ? i : (p[i] = findSet(p[i]));
		}

		boolean isSameSet(int i, int j) {
			return findSet(i) == findSet(j);
		}

		void unionSet(int i, int j) {
			if (!isSameSet(i, j)) // if from different set
			{
				numDisjoint--;
				int x = findSet(i), y = findSet(j);
				if (r[x] > r[y]) {
					p[y] = x; // rank keeps the tree short
					s[x] += s[y];
				} else {
					p[x] = y;
					if (r[x] == r[y])
						r[y]++;
					s[y] += s[x];
				}
			}
		}

		int sizeOfSet(int i) {
			return s[findSet(i)];
		}
	};

}

import java.io.*;
import java.util.*;

public class Solution {
    static MyScanner sc;
    private static PrintWriter out;
    static long M2 = 1_000_000_000L + 7;

    public static void main(String[] s) throws Exception {
        StringBuilder stringBuilder = new StringBuilder();
        if (stringBuilder.length() == 0) {
            sc = new MyScanner(System.in);
        } else {
            sc = new MyScanner(new BufferedReader(new StringReader(stringBuilder.toString())));
        }

        out = new PrintWriter(new OutputStreamWriter(System.out));
        initData();
        solve();
        out.flush();
    }

    private static void initData() {
    }

    private static void solve() throws IOException {

        int k = sc.nextInt();
        int a = sc.nextInt();
        int b = sc.nextInt();

        long in = pow(a + b, M2 - 2, M2);

        long va = (a * in) % M2;
        long vb = (b * in) % M2;

        long[][] resk = new long[k][k + 1];

        long bpoison = a * pow(b, M2 - 2, M2);

        resk[0][1] = 1;

        long res = 0;
        for (int t = 0; t < k; t++) {
            for (int x = 1; x < k; x++) {
                resk[t][x + 1] += (resk[t][x] * va) % M2;
                resk[t][x + 1] %= M2;
                if (t + x >= k) {
                    long tt = (resk[t][x] * vb) % M2;
                    tt *= (t + x);
                    res += tt % M2;
                } else {
                    resk[t + x][x] += resk[t][x] * vb % M2;
                    resk[t + x][x] %= M2;
                }
            }
        }

        for (int l = 0; l < k; l++) {
            res += ((l + k) * resk[l][k]) % M2;
            res += (resk[l][k] * bpoison) % M2;
            res %= M2;
        }

        out.println(res);
    }

    private static void solveT() throws IOException {
        int t = sc.nextInt();
        while (t-- > 0) {
            solve();
        }
    }

    private static long gcd(long l, long l1) {
        if (l > l1) return gcd(l1, l);
        if (l == 0) return l1;
        return gcd(l1 % l, l);
    }

    private static long pow(long a, long b, long m) {
        if (b == 0) return 1;
        if (b == 1) return a;
        long pp = pow(a, b / 2, m);
        pp *= pp;
        pp %= m;
        return (pp * (b % 2 == 0 ? 1 : a)) % m;
    }

    static class MyScanner {
        BufferedReader br;
        StringTokenizer st;

        MyScanner(BufferedReader br) {
            this.br = br;
        }

        public MyScanner(InputStream in) {
            this(new BufferedReader(new InputStreamReader(in)));
        }

        void findToken() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }

        String next() {
            findToken();
            return st.nextToken();
        }

        Integer[] nab(int n) {
            Integer[] k = new Integer[n];
            for (int i = 0; i < n; i++) {
                k[i] = sc.fi();
            }
            return k;
        }

        int[] na(int n) {
            int[] k = new int[n];
            for (int i = 0; i < n; i++) {
                k[i] = sc.fi();
            }
            return k;
        }

        long[] nl(int n) {
            long[] k = new long[n];
            for (int i = 0; i < n; i++) {
                k[i] = sc.nextLong();
            }
            return k;
        }

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

        int fi() {
            String t = next();
            int cur = 0;
            boolean n = t.charAt(0) == '-';
            for (int a = n ? 1 : 0; a < t.length(); a++) {
                cur = cur * 10 + t.charAt(a) - '0';
            }
            return n ? -cur : cur;
        }

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

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

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Scanner;
import java.util.*;

public class Main {

    static int K, pA, pB, totInv, invB;
    static int [][] dp;
    static final int M = (int) 1e9 + 7;
    static long pBinv;

    static int solve(int as, int k) {
        // at least K
        if(k >= K)
            return as;
        if(as >= K) {
           return (int) ((1l * pBinv + as + k - 1 + M) % M);
        }
        if(dp[as][k] != -1)
            return dp[as][k];
        // put a
        long ansA = 1l * pA * solve(as + 1, k) % M * totInv % M;
        // put b
        long ansB = 1l * pB * solve(as, k + as) % M * totInv % M;

        return dp[as][k] = (int)((ansA + ansB) % M);
    }

    static long modPow(long a, long e) {

        long res = 1;
        while(e > 0) {
            if((e & 1) == 1)
                res = (res * a) % M;
            a = (a * a) % M;
            e >>= 1;
        }

        return res % M;
    }

    static void build() {
        totInv = (int) modPow((pA + pB), M - 2);
        invB = (int) modPow(pB, M - 2);
        for(int i = 0; i <= 1002; ++i)
            Arrays.fill(dp[i], -1);

        pBinv = 1l * (pA + pB) * invB % M;
    }

    public static void main(String[] args) throws IOException{
        Scanner sc = new Scanner();
        PrintWriter out = new PrintWriter(System.out);
        K = sc.nextInt();
        pA = sc.nextInt();
        pB = sc.nextInt();
        dp = new int[1003][1003];
        build();
        System.out.println(solve(1, 0));
    }

    static class Scanner {
        BufferedReader br;
        StringTokenizer st;

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

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

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

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

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

        String nextLine() throws IOException {
            return br.readLine();
        }

    }
    }

import java.io.*;
import java.math.BigInteger;
import java.util.*;

public class Solution {

    public static void main(String[] args) throws Exception {
        MyReader reader = new MyReader(System.in);
//        MyReader reader = new MyReader(new FileInputStream("input.txt"));
        MyWriter writer = new MyWriter(System.out);
        new Solution().run(reader, writer);
        writer.close();
    }

    private void run(MyReader reader, MyWriter writer) throws IOException {
        int k = reader.nextInt();
        int a = reader.nextInt();
        int b = reader.nextInt();
        long mod = 1_000_000_007;
        long a1 = a * f(a + b) % mod;
        long b1 = b * f(a + b) % mod;
        long qq = a * f(b) % mod;
        long[][] d = new long[k + 1][k];
        d[1][0] = 1;
        for (int i = 1; i < k; i++) {
            for (int j = 0; j < k; j++) {
                d[i + 1][j] = (d[i + 1][j] + d[i][j] * a1) % mod;
                if (i + j < k) {
                    d[i][i + j] = (d[i][i + j] + d[i][j] * b1) % mod;
                }
            }
        }
        long ans = 0;
        for (int i = 1; i < k; i++) {
            for (int j = k - i; j < k; j++) {
                ans = (ans + (i + j) * d[i][j] * b1) % mod;
            }
        }
        for (int i = 0; i < k; i++) {
            ans = (ans + d[k][i] * (i + k + qq)) % mod;
        }
        writer.print(ans);
    }

    private BigInteger bb = new BigInteger("-1");
    private BigInteger mod = new BigInteger("1000000007");

    private long f(long a) {
        BigInteger q = new BigInteger(a + "");
        return q.modPow(bb, mod).longValue();
    }

    static class MyReader {

        final BufferedInputStream in;
        final int bufSize = 1 << 16;
        final byte buf[] = new byte[bufSize];
        int i = bufSize;
        int k = bufSize;
        boolean end = false;
        final StringBuilder str = new StringBuilder();

        MyReader(InputStream in) {
            this.in = new BufferedInputStream(in, bufSize);
        }

        int nextInt() throws IOException {
            return (int) nextLong();
        }

        int[] nextIntArray(int n) throws IOException {
            int[] m = new int[n];
            for (int i = 0; i < n; i++) {
                m[i] = nextInt();
            }
            return m;
        }

        int[][] nextIntMatrix(int n, int m) throws IOException {
            int[][] a = new int[n][0];
            for (int j = 0; j < n; j++) {
                a[j] = nextIntArray(m);
            }
            return a;
        }

        long nextLong() throws IOException {
            int c;
            long x = 0;
            boolean sign = true;
            while ((c = nextChar()) <= 32) ;
            if (c == '-') {
                sign = false;
                c = nextChar();
            }
            if (c == '+') {
                c = nextChar();
            }
            while (c >= '0') {
                x = x * 10 + (c - '0');
                c = nextChar();
            }
            return sign ? x : -x;
        }

        long[] nextLongArray(int n) throws IOException {
            long[] m = new long[n];
            for (int i = 0; i < n; i++) {
                m[i] = nextLong();
            }
            return m;
        }

        int nextChar() throws IOException {
            if (i == k) {
                k = in.read(buf, 0, bufSize);
                i = 0;
            }
            return i >= k ? -1 : buf[i++];
        }

        String nextString() throws IOException {
            if (end) {
                return null;
            }
            str.setLength(0);
            int c;
            while ((c = nextChar()) <= 32 && c != -1) ;
            if (c == -1) {
                end = true;
                return null;
            }
            while (c > 32) {
                str.append((char) c);
                c = nextChar();
            }
            return str.toString();
        }

        String nextLine() throws IOException {
            if (end) {
                return null;
            }
            str.setLength(0);
            int c = nextChar();
            while (c != '\n' && c != '\r' && c != -1) {
                str.append((char) c);
                c = nextChar();
            }
            if (c == -1) {
                end = true;
                if (str.length() == 0) {
                    return null;
                }
            }
            if (c == '\r') {
                nextChar();
            }
            return str.toString();
        }

        char[] nextCharArray() throws IOException {
            return nextString().toCharArray();
        }

        char[][] nextCharMatrix(int n) throws IOException {
            char[][] a = new char[n][0];
            for (int i = 0; i < n; i++) {
                a[i] = nextCharArray();
            }
            return a;
        }
    }

    static class MyWriter {

        final BufferedOutputStream out;
        final int bufSize = 1 << 16;
        final byte buf[] = new byte[bufSize];
        int i = 0;
        final byte c[] = new byte[30];
        static final String newLine = System.getProperty("line.separator");

        MyWriter(OutputStream out) {
            this.out = new BufferedOutputStream(out, bufSize);
        }

        void print(long x) throws IOException {
            int j = 0;
            if (i + 30 >= bufSize) {
                flush();
            }
            if (x < 0) {
                buf[i++] = (byte) ('-');
                x = -x;
            }
            while (j == 0 || x != 0) {
                c[j++] = (byte) (x % 10 + '0');
                x /= 10;
            }
            while (j-- > 0)
                buf[i++] = c[j];
        }

        void print(int[] m) throws IOException {
            for (int a : m) {
                print(a);
                print(' ');
            }
        }

        void print(long[] m) throws IOException {
            for (long a : m) {
                print(a);
                print(' ');
            }
        }

        void print(String s) throws IOException {
            for (int i = 0; i < s.length(); i++) {
                print(s.charAt(i));
            }
        }

        void print(char x) throws IOException {
            if (i == bufSize) {
                flush();
            }
            buf[i++] = (byte) x;
        }

        void print(char[] m) throws IOException {
            for (char c : m) {
                print(c);
            }
        }

        void println(String s) throws IOException {
            print(s);
            println();
        }

        void println() throws IOException {
            print(newLine);
        }

        void flush() throws IOException {
            out.write(buf, 0, i);
            out.flush();
            i = 0;
        }

        void close() throws IOException {
            flush();
            out.close();
        }
    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.InputStream;
/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskD solver = new TaskD();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskD {
        public final Rational ONE = new Rational(1, 1);
        public final Rational ZERO = new Rational(0, 1);

        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int k = in.readInt();
            int pa = in.readInt();
            int pb = in.readInt();
            Rational probA = new Rational(pa, pa + pb);
            Rational probB = new Rational(pb, pa + pb);
            Rational[][] probAtState = new Rational[k + 2][2 * k + 2]; // numA, ABPairAlready
            for (int row = 0; row < probAtState.length; row++) {
                for (int col = 0; col < probAtState[0].length; col++) {
                    probAtState[row][col] = ZERO;
                }
            }
            probAtState[1][0] = ONE;
            for (int numA = 1; numA < k; numA++) {
                for (int ABPairAlready = 0; ABPairAlready < k; ABPairAlready++) {
                    { // with chance pa / (pa + pb) we get an A here
                        probAtState[numA + 1][ABPairAlready] = probAtState[numA + 1][ABPairAlready].add(probAtState[numA][ABPairAlready].multiply(probA));
                    }
                    { // with chance pb / (pa + pb) we get a B here
                        probAtState[numA][ABPairAlready + numA] = probAtState[numA][ABPairAlready + numA].add(probAtState[numA][ABPairAlready].multiply(probB));
                    }
                }
            }
            Rational res = ZERO;
            // Here we count num ABPairs where we have at least k AB pairs already
            for (int numA = 1; numA < probAtState.length; numA++) {
                for (int ABPairAlready = k; ABPairAlready < probAtState[0].length; ABPairAlready++) {
                    res = res.add(probAtState[numA][ABPairAlready].multiply(new Rational(ABPairAlready, 1)));
                }
            }
            Rational expectMoreA = (probB.reverse()).subtract(ONE);
            for (int ABPairAlready = 0; ABPairAlready < k; ABPairAlready++) {
                // Now here we do not quite have the number of AB Pairs we need
                // but we have plenty of A already
                Rational nowA = new Rational(k, 1).add(expectMoreA).add(new Rational(ABPairAlready, 1));
                Rational moar = nowA.multiply(probAtState[k][ABPairAlready]);
                res = res.add(moar);
            }
            out.printLine((long) res.numerator * IntegerUtils.reverse(res.denominator, MiscUtils.MOD7) % MiscUtils.MOD7);
        }

        public class Rational {
            public final long numerator;
            public final long denominator;

            public Rational(long numerator, long denominator) {
                if (denominator == 0) {
                    throw new IllegalArgumentException();
                }
                long gcd = IntegerUtils.gcd(Math.abs(numerator), Math.abs(denominator));
                if (denominator > 0) {
                    this.numerator = numerator / gcd;
                    this.denominator = denominator / gcd;
                } else {
                    this.numerator = -numerator / gcd;
                    this.denominator = -denominator / gcd;
                }
            }

            public String toString() {
                return numerator + "/" + denominator;
            }

            public Rational add(Rational other) {
                return new Rational(numerator * other.denominator + denominator * other.numerator,
                        denominator * other.denominator);
            }

            public Rational reverse() {
                if (numerator == 0) {
                    throw new ArithmeticException();
                }
                return new Rational(denominator, numerator);
            }

            public Rational subtract(Rational other) {
                return new Rational(numerator * other.denominator - denominator * other.numerator,
                        denominator * other.denominator);
            }

            public Rational multiply(Rational other) {
                return new Rational(numerator * other.numerator, other.denominator * denominator);
            }
        }
    }
    static class MiscUtils {
        public static final int MOD7 = (int) (1e9 + 7);
    }
    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

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

        public void printLine(long i) {
            writer.println(i);
        }
    }
    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int readInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);
        }
    }
    static class IntegerUtils {
        public static long gcd(long a, long b) {
            a = Math.abs(a);
            b = Math.abs(b);
            while (b != 0) {
                long temp = a % b;
                a = b;
                b = temp;
            }
            return a;
        }

        public static long power(long base, long exponent, long mod) {
            if (base >= mod) {
                base %= mod;
            }
            if (exponent == 0) {
                return 1 % mod;
            }
            long result = power(base, exponent >> 1, mod);
            result = result * result % mod;
            if ((exponent & 1) != 0) {
                result = result * base % mod;
            }
            return result;
        }

        public static long reverse(long number, long module) {
            return power(number, module - 2, module);
        }
    }
}

/*
If you want to aim high, aim high
Don't let that studying and grades consume you
Just live life young
******************************
If I'm the sun, you're the moon
Because when I go up, you go down
*******************************
I'm working for the day I will surpass you
https://www.a2oj.com/Ladder16.html
*/
import java.util.*;
import java.io.*;
import java.math.*;

   public class D
   {
      static long MOD = 1000000007L;
      static int K;
      static long pa;
      static long pb;
      static long cancer1; // 1/(1-pa)
      static long cancer2; // 1/(1-pb)
      static long cancer3; // pa/(pa-1)^2
      public static void main(String omkar[]) throws Exception
      {
         BufferedReader infile = new BufferedReader(new InputStreamReader(System.in));
         StringTokenizer st = new StringTokenizer(infile.readLine());
         K = Integer.parseInt(st.nextToken());
         long p1 = Long.parseLong(st.nextToken());
         long p2 = Long.parseLong(st.nextToken());
         //solve
         pa = (p1*power(p1+p2,MOD-2,MOD))%MOD;
         pb = (p2*power(p1+p2,MOD-2,MOD))%MOD;
         cancer1 = (p1+p2)%MOD;
         cancer1 = (cancer1*power(p2,MOD-2,MOD))%MOD;

         cancer2 = (p1+p2)%MOD;
         cancer2 = (cancer2*power(p1,MOD-2,MOD))%MOD;
         /*
         cancer3 = (pa*power(p1+p2,2,MOD))%MOD;
         cancer3 = (cancer3*power(power(p2,2,MOD),MOD-2,MOD))%MOD;
         */
         cancer3 = power(p1,2,MOD)+p1*p2%MOD;
         cancer3 %= MOD;
         cancer3 = (cancer3*power(power(p2,2,MOD),MOD-2,MOD))%MOD;

         long res = dfs(0, 0);
         System.out.println(res%MOD);
      }
      public static long dfs(int k, int a)
      {
         if(K-k <= a)
         {
            //geometric
            long temp = ((long)a*cancer1)%MOD;
            temp = (temp+cancer3)%MOD;
            temp = (temp*pb)%MOD;
            return temp;
         }
         if(a > 0)
            return ((pa*dfs(k,a+1))%MOD+(pb*dfs(k+a,a))%MOD)%MOD;
         else
         {
            /*
            long boof = power(1-pb+MOD, MOD-2, MOD);
            boof = (pa*boof)%MOD;
            return (boof*((pa*dfs(k,a+1))%MOD))%MOD;
            */
            long val = dfs(k,a+1);
            val = (pa*val)%MOD;
            long boof = cancer2;
            return (boof*val)%MOD;
         }
      }
      public static long power(long x, long y, long p)
      {
          long res = 1L;
          x = x % p;
          while (y > 0)
          {
              if((y & 1)==1)
                  res = (res * x) % p;
              y = y >> 1;
              x = (x * x) % p;
          }
          return res;
      }
   }

/*
If you want to aim high, aim high
Don't let that studying and grades consume you
Just live life young
******************************
If I'm the sun, you're the moon
Because when I go up, you go down
*******************************
I'm working for the day I will surpass you
https://www.a2oj.com/Ladder16.html
*/
import java.util.*;
import java.io.*;
import java.math.*;

   public class D2
   {
      static long MOD = 1000000007L;
      public static void main(String omkar[]) throws Exception
      {
         BufferedReader infile = new BufferedReader(new InputStreamReader(System.in));
         StringTokenizer st = new StringTokenizer(infile.readLine());
         int K = Integer.parseInt(st.nextToken());
         long pa = Long.parseLong(st.nextToken());
         long pb = Long.parseLong(st.nextToken());
         //brain tumor
         long denom = power(pa+pb, MOD-2, MOD);
         long cancer = ((pa+pb)*power(pb,MOD-2,MOD))%MOD;
         long[][] dp = new long[K+1][K+1];
         for(int k=dp.length-1; k >= 0; k--)
            for(int a=dp[k].length-1; a >= 0; a--)
            {
               if(k >= K)
                  dp[k][a] = k;
               else if(k+a >= K)
                  dp[k][a] = (cancer+a+k-1)%MOD;
               else
               {
                  dp[k][a] = ((pa*dp[k][a+1]%MOD+pb*dp[k+a][a]%MOD)*denom)%MOD;
                  dp[k][a] = (dp[k][a]*power(pa+pb,MOD-2,MOD))%MOD;
               }
            }
         System.out.println(dp[0][1]%MOD);
      }
      public static long power(long x, long y, long p)
      {
          long res = 1L;
          x = x % p;
          while (y > 0)
          {
              if((y & 1)==1)
                  res = (res * x) % p;
              y = y >> 1;
              x = (x * x) % p;
          }
          return res;
      }
   }

import java.util.*;
import java.io.*;
import java.math.*;
public class A{

    void solve(){
        k=ni();
        long pa=ni(),pb=ni();
        p1=(pa*modInverse(pa+pb,M))%M;
        p2=(pb*modInverse(pa+pb,M))%M;
        dp=new long[k+1][k+1];
        for(int i=0;i<=k;i++)Arrays.fill(dp[i],-1);
        long ans=go(1,0)%M;

        pw.println(ans);

    }
    int k;
    long p1,p2;
    long dp[][];
    long go(int a, int cnt){
        if(cnt>=k) {
            long d=modInverse(p1,M);
            d=(d*cnt)%M;
            return d;
        }
        if(a+cnt>=k) {
            long d=((cnt + a) * p2) % M;
            d=(d*modInverse(p1,M))%M;
            return d;

        }
        if(dp[a][cnt]!=-1) return dp[a][cnt];

        long cc=0;
        cc=(cc+p1*go(a+1,cnt)%M)%M;
        cc=(cc+p2*go(a,cnt+a)%M)%M;
        dp[a][cnt]=cc;
        return cc;
    }

    static long d, x, y;
    static void extendedEuclid(long A, long B) {
        if(B == 0) {
            d = A;
            x = 1;
            y = 0;
        }
        else {
            extendedEuclid(B, A%B);
            long temp = x;
            x = y;
            y = temp - (A/B)*y;
        }
    }
    static long modInverse(long A, long M){
        extendedEuclid(A,M);
        return (x%M+M)%M;
    }

    long M=(long)1e9+7;
    InputStream is;
    PrintWriter pw;
    String INPUT = "";
    void run() throws Exception {
        is = INPUT.isEmpty() ? System.in : new ByteArrayInputStream(INPUT.getBytes());
        pw = new PrintWriter(System.out);
        long s = System.currentTimeMillis();
        solve();
        pw.flush();
        if(!INPUT.isEmpty())tr(System.currentTimeMillis()-s+"ms");
    }

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

    private byte[] inbuf = new byte[1024];
    public int lenbuf = 0, ptrbuf = 0;

    private int readByte() {
        if(lenbuf == -1)throw new InputMismatchException();
        if(ptrbuf >= lenbuf){
            ptrbuf = 0;
            try { lenbuf = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }
            if(lenbuf <= 0)return -1;
        }
        return inbuf[ptrbuf++];
    }

    private boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }
    private int skip() { int b; while((b = readByte()) != -1 && isSpaceChar(b)); return b; }

    private double nd() { return Double.parseDouble(ns()); }
    private char nc() { return (char)skip(); }

    private String ns() {
        int b = skip();
        StringBuilder sb = new StringBuilder();
        while(!(isSpaceChar(b))){ // when nextLine, (isSpaceChar(b) && b != ' ')
            sb.appendCodePoint(b);
            b = readByte();
        }
        return sb.toString();
    }

    private char[] ns(int n) {
        char[] buf = new char[n];
        int b = skip(), p = 0;
        while(p < n && !(isSpaceChar(b))){
            buf[p++] = (char)b;
            b = readByte();
        }
        return n == p ? buf : Arrays.copyOf(buf, p);
    }

    private char[][] nm(int n, int m) {
        char[][] map = new char[n][];
        for(int i = 0;i < n;i++)map[i] = ns(m);
        return map;
    }

    private int[] na(int n) {
        int[] a = new int[n];
        for(int i = 0;i < n;i++)a[i] = ni();
        return a;
    }

    private int ni() {
        int num = 0, b;
        boolean minus = false;
        while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
        if(b == '-'){
            minus = true;
            b = readByte();
        }

        while(true){
            if(b >= '0' && b <= '9'){
                num = num * 10 + (b - '0');
            }else{
                return minus ? -num : num;
            }
            b = readByte();
        }
    }

    private long nl() {
        long num = 0;
        int b;
        boolean minus = false;
        while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
        if(b == '-'){
            minus = true;
            b = readByte();
        }

        while(true){
            if(b >= '0' && b <= '9'){
                num = num * 10 + (b - '0');
            }else{
                return minus ? -num : num;
            }
            b = readByte();
        }
    }

    private void tr(Object... o) { if(INPUT.length() > 0)System.out.println(Arrays.deepToString(o)); }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author rishus23
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskD solver = new TaskD();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskD {
        static long mod;
        static long k;
        static long a;
        static long b;
        static long ia;
        static long ib;
        static long iab;
        static long[][] dp;

        public void solve(int testNumber, InputReader in, OutputWriter out) {
            mod = (long) (1e9 + 7);
            k = in.nextLong();
            a = in.nextLong();
            b = in.nextLong();
            ia = pow(a, mod - 2);
            ib = pow(b, mod - 2);
            iab = pow(a + b, mod - 2);
            dp = new long[(int) k + 1][(int) k + 1];
            for (long[] arr : dp)
                Arrays.fill(arr, -1);
            out.println(s(1, 0));
        }

        private long s(int sa, int ab) {
            long x = 1L;
            if (sa + ab >= k) {
                return (x * (a + b) * ib - 1 + sa + ab);
            }
            if (dp[sa][ab] != -1)
                return dp[sa][ab];
            dp[sa][ab] = ((x * a * s(sa + 1, ab) % mod) * iab + (x * b * s(sa, sa + ab) % mod) * iab) % mod;
            return dp[sa][ab];
        }

        long pow(long t, long p) {
            if (p == 0)
                return 1;
            if (p % 2 == 1)
                return t * pow(t, p - 1) % mod;
            else
                return pow((t * t) % mod, p / 2) % mod;
        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

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

        public void println(long i) {
            writer.println(i);
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public long nextLong() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            long res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }
}

import static java.util.Arrays.*;

import java.util.*;
import java.util.ArrayList;

public class D {

	public D () {
		K = sc.nextInt();
		long PA = sc.nextLong(), PB = sc.nextLong();
		pA = PA * modInv(PA + PB); pB = PB * modInv(PA + PB);
		ipB = modInv(pB);
		F = new long [K][K];
		for (long [] f : F) fill(f, -1);

		long res = f(0, 0);
		exit(res);
	}

	int K;
	long pA, pB, ipB;
	long [][] F;

	long f(int j, int n) {
		if (j >= K)
			return j;
		if (n >= K)
			return (j + n + pA * ipB) % MOD;
		if (F[j][n] != -1)
			return F[j][n];
		if (n == 0)
			return F[j][0] = f(j, 1);
		return F[j][n] = (pA * f(j, n+1) + pB * f(j+n, n)) % MOD;
	}

	private static final int MOD = (int) 1e9 + 7;
	private static long [] distinctPrimeDivisors(long N) {
		List<Long> res = new ArrayList<Long>();
		for (long p = 2; p*p <= N; ++p) {
			if (N % p == 0)
				res.add(p);
			while (N % p == 0)
				N /= p;
		}
		if (N > 1)
			res.add(N);
		return pri(res.toArray(new Long[0]));
	}
	private static long fi (int N) {
		long res = N;
		for (long p : distinctPrimeDivisors(N))
			res = res * (p-1) / p;
		return res;
	}
	private static long modInv(long x) { return modInv(x, MOD); }
	private static long modInv(long x, int mod) {
		long res = modPow(x, fi(mod) - 1, mod);
		assert (res * x) % mod == 1 : "gcd(" + x + ", " + mod + ") != 1";
		return res;
	}
	private static long modPow (long b, long e, int mod) {
		if (e == 0) return 1;
		if (b == 0) return 0;
		if (e == 1) return b;
		long res = 1; int s = Long.numberOfTrailingZeros(Long.highestOneBit(e));
		for (int j = s; j >= 0; --j) {
			res = (res * res) % mod;
			if ((e & (1L << j)) != 0)
				res = (res * b) % mod;
		}
		return res;
	}
	private static long [] pri (Long [] A) { return pri(A, new long [A.length]); }
	private static long [] pri (Long [] A, long [] a) { for (int i = 0; i < A.length; ++i) a[i] = A[i]; return a; }
	////////////////////////////////////////////////////////////////////////////////////
	private final static IOUtils.MyScanner sc = new IOUtils.MyScanner();
	private static void exit (Object o, Object ... A) { IOUtils.print(o, A); IOUtils.exit(); }
	private static class IOUtils {
		public static class MyScanner {
			public String next() { newLine(); return line[index++]; }
			public int nextInt() { return Integer.parseInt(next()); }
			public long nextLong() { return Long.parseLong(next()); }
			//////////////////////////////////////////////
			private boolean eol() { return index == line.length; }
			private String readLine() {
				try {
					return r.readLine();
				} catch (Exception e) {
					throw new Error (e);
				}
			}
			private final java.io.BufferedReader r;
			private MyScanner () { this(new java.io.BufferedReader(new java.io.InputStreamReader(System.in))); }
			private MyScanner (java.io.BufferedReader r) {
				try {
					this.r = r;
					while (!r.ready())
						Thread.sleep(1);
					start();
				} catch (Exception e) {
					throw new Error(e);
				}
			}
			private String [] line;
			private int index;
			private void newLine() {
				if (line == null || eol()) {
					line = split(readLine());
					index = 0;
				}
			}
			private String [] split(String s) { return s.length() > 0 ? s.split(" ") : new String [0]; }
		}
		private static String build(Object o, Object ... A) { return buildDelim(" ", o, A); }
		private static String buildDelim(String delim, Object o, Object ... A) {
			StringBuilder b = new StringBuilder();
			append(b, o, delim);
			for (Object p : A)
				append(b, p, delim);
			return b.substring(delim.length());
		}
		//////////////////////////////////////////////////////////////////////////////////
		private static void start() { if (t == 0) t = millis(); }
		private static void append(StringBuilder b, Object o, String delim) {
			if (o.getClass().isArray()) {
				int len = java.lang.reflect.Array.getLength(o);
				for (int i = 0; i < len; ++i)
					append(b, java.lang.reflect.Array.get(o, i), delim);
			} else if (o instanceof Iterable<?>)
				for (Object p : (Iterable<?>) o)
					append(b, p, delim);
			else {
				if (o instanceof Double)
					o = new java.text.DecimalFormat("#.############").format(o);
				b.append(delim).append(o);
			}
		}
		private static java.io.PrintWriter pw = new java.io.PrintWriter(System.out);
		private static void print(Object o, Object ... A) { pw.println(build(o, A)); }
		private static void err(Object o, Object ... A) { System.err.println(build(o, A)); }
		private static void exit() {
			IOUtils.pw.close();
			System.out.flush();
			err("------------------");
			err(IOUtils.time());
			System.exit(0);
		}
		private static long t;
		private static long millis() { return System.currentTimeMillis(); }
		private static String time() { return "Time: " + (millis() - t) / 1000.0; }
	}
	public static void main (String[] args) { new D(); IOUtils.exit(); }
}

import static java.util.Arrays.*;

import java.util.*;
import java.util.ArrayList;

public class D {

	public D () {
		K = sc.nextInt();
		long PA = sc.nextLong(), PB = sc.nextLong();
		pA = PA * modInv(PA + PB); pB = PB * modInv(PA + PB);
		ipB = modInv(pB);
		F = new long [K][K];
		for (long [] f : F) fill(f, -1);

		long res = f(0, 0);
		exit(res);
	}

	int K;
	long pA, pB, ipB;
	long [][] F;

	long f(int j, int n) {
		if (n >= K)
			return (j + n + pA * ipB) % MOD;
		if (j >= K)
			return j;
		if (F[j][n] != -1)
			return F[j][n];
		if (n == 0)
			return F[j][0] = f(j, 1);
		return F[j][n] = (pA * f(j, n+1) + pB * f(j+n, n)) % MOD;
	}

	private static final int MOD = (int) 1e9 + 7;
	private static long [] distinctPrimeDivisors(long N) {
		List<Long> res = new ArrayList<Long>();
		for (long p = 2; p*p <= N; ++p) {
			if (N % p == 0)
				res.add(p);
			while (N % p == 0)
				N /= p;
		}
		if (N > 1)
			res.add(N);
		return pri(res.toArray(new Long[0]));
	}
	private static long fi (int N) {
		long res = N;
		for (long p : distinctPrimeDivisors(N))
			res = res * (p-1) / p;
		return res;
	}
	private static long modInv(long x) { return modInv(x, MOD); }
	private static long modInv(long x, int mod) {
		long res = modPow(x, fi(mod) - 1, mod);
		assert (res * x) % mod == 1 : "gcd(" + x + ", " + mod + ") != 1";
		return res;
	}
	private static long modPow (long b, long e, int mod) {
		if (e == 0) return 1;
		if (b == 0) return 0;
		if (e == 1) return b;
		long res = 1; int s = Long.numberOfTrailingZeros(Long.highestOneBit(e));
		for (int j = s; j >= 0; --j) {
			res = (res * res) % mod;
			if ((e & (1L << j)) != 0)
				res = (res * b) % mod;
		}
		return res;
	}
	private static long [] pri (Long [] A) { return pri(A, new long [A.length]); }
	private static long [] pri (Long [] A, long [] a) { for (int i = 0; i < A.length; ++i) a[i] = A[i]; return a; }
	////////////////////////////////////////////////////////////////////////////////////
	private final static IOUtils.MyScanner sc = new IOUtils.MyScanner();
	private static void exit (Object o, Object ... A) { IOUtils.print(o, A); IOUtils.exit(); }
	private static class IOUtils {
		public static class MyScanner {
			public String next() { newLine(); return line[index++]; }
			public int nextInt() { return Integer.parseInt(next()); }
			public long nextLong() { return Long.parseLong(next()); }
			//////////////////////////////////////////////
			private boolean eol() { return index == line.length; }
			private String readLine() {
				try {
					return r.readLine();
				} catch (Exception e) {
					throw new Error (e);
				}
			}
			private final java.io.BufferedReader r;
			private MyScanner () { this(new java.io.BufferedReader(new java.io.InputStreamReader(System.in))); }
			private MyScanner (java.io.BufferedReader r) {
				try {
					this.r = r;
					while (!r.ready())
						Thread.sleep(1);
					start();
				} catch (Exception e) {
					throw new Error(e);
				}
			}
			private String [] line;
			private int index;
			private void newLine() {
				if (line == null || eol()) {
					line = split(readLine());
					index = 0;
				}
			}
			private String [] split(String s) { return s.length() > 0 ? s.split(" ") : new String [0]; }
		}
		private static String build(Object o, Object ... A) { return buildDelim(" ", o, A); }
		private static String buildDelim(String delim, Object o, Object ... A) {
			StringBuilder b = new StringBuilder();
			append(b, o, delim);
			for (Object p : A)
				append(b, p, delim);
			return b.substring(delim.length());
		}
		//////////////////////////////////////////////////////////////////////////////////
		private static void start() { if (t == 0) t = millis(); }
		private static void append(StringBuilder b, Object o, String delim) {
			if (o.getClass().isArray()) {
				int len = java.lang.reflect.Array.getLength(o);
				for (int i = 0; i < len; ++i)
					append(b, java.lang.reflect.Array.get(o, i), delim);
			} else if (o instanceof Iterable<?>)
				for (Object p : (Iterable<?>) o)
					append(b, p, delim);
			else {
				if (o instanceof Double)
					o = new java.text.DecimalFormat("#.############").format(o);
				b.append(delim).append(o);
			}
		}
		private static java.io.PrintWriter pw = new java.io.PrintWriter(System.out);
		private static void print(Object o, Object ... A) { pw.println(build(o, A)); }
		private static void err(Object o, Object ... A) { System.err.println(build(o, A)); }
		private static void exit() {
			IOUtils.pw.close();
			System.out.flush();
			err("------------------");
			err(IOUtils.time());
			System.exit(0);
		}
		private static long t;
		private static long millis() { return System.currentTimeMillis(); }
		private static String time() { return "Time: " + (millis() - t) / 1000.0; }
	}
	public static void main (String[] args) { new D(); IOUtils.exit(); }
}

import java.io.*;
import java.util.*;
public class newyear {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskE solver = new TaskE();
        solver.solve(1, in, out);
        out.close();
    }
        static class TaskE {
        class pair{
        	int n,v;pair(int a,int b){n=a;v=b;}
        }
        long rec(int na,int nc,int k,int L) {
        	if(nc>=k)return cal(nc);
        	if(L==k)return (pb*cal(na+nc))%mod;
        	if(dp[na][nc]!=0)return dp[na][nc];
        	dp[na][nc]=((pb*rec(na,na+nc,k,L+1))%mod+(pa*rec(na+1,nc,k,L+1))%mod)%mod;
    		return dp[na][nc];
        }
        long cal(long x) {
        	return ((x*C)%mod+((pa*C)%mod*C)%mod)%mod;
        }
        long rpe(long a,long b) {
        	long r=1;
        	while(b!=0) {
        		if(b%2!=0)r=(r*a)%mod;
        		a=(a*a)%mod;b/=2;
        	}return r;
        }
        long dp[][],mod=(long)(1E9)+7,pa,pb,C;
         public void solve(int testNumber, InputReader in, PrintWriter out) {
          int k=in.nextInt();pa=in.nextLong();pb=in.nextLong();
          long I=rpe(pa+pb,mod-2);pa=(pa*I)%mod;pb=(pb*I)%mod;
          dp=new long[1001][1001];
          long m=rpe(1-pb+mod,mod-2);C=rpe(1-pa+mod,mod-2);//System.out.println(m);
          out.print(((pa*rec(1,0,k,1))%mod*m)%mod);
         }
    }
    static class InputReader {
        BufferedReader br;
        StringTokenizer st;
        public InputReader(InputStream stream) {
            br = new BufferedReader(new InputStreamReader(stream));
            st = null;
        }

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

        boolean hasMoreTokens() {
            while (st == null || !st.hasMoreTokens()) {
                String s = null;
                try {
                    s = br.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (s == null)
                    return false;
                st = new StringTokenizer(s);
            }
            return true;
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }
        public long nextLong() {
            return Long.parseLong(next());
        }
        public double nextDouble() {
            return Double.parseDouble(next());
        }
    }
}

import java.io.*;
import java.util.*;
public class newyear {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskE solver = new TaskE();
        solver.solve(1, in, out);
        out.close();
    }
        static class TaskE {
        class pair{
        	int n,v;pair(int a,int b){n=a;v=b;}
        }
        long rec(int na,int nc,int k,int L) {
        	if(nc>=k)return cal(nc+na);
        	if(L==k)return dp[na][nc]=(pb*cal(na+nc))%mod;
        	if(dp[na][nc]!=0)return dp[na][nc];
        	dp[na][nc]=((pb*rec(na,na+nc,k,L+1))%mod+(pa*rec(na+1,nc,k,L+1))%mod)%mod;
    		return dp[na][nc];
        }
        long cal(long x) {
        	return ((x*C)%mod+((pa*C)%mod*C)%mod)%mod;
        }
        long rpe(long a,long b) {
        	long r=1;
        	while(b!=0) {
        		if(b%2!=0)r=(r*a)%mod;
        		a=(a*a)%mod;b/=2;
        	}return r;
        }
        long dp[][],mod=(long)(1E9)+7,pa,pb,C;
         public void solve(int testNumber, InputReader in, PrintWriter out) {
          int k=in.nextInt();pa=in.nextLong();pb=in.nextLong();
          long I=rpe(pa+pb,mod-2);pa=(pa*I)%mod;pb=(pb*I)%mod;
          dp=new long[1001][1001];
          long m=rpe(1-pb+mod,mod-2);C=rpe(1-pa+mod,mod-2);//System.out.println(m);
          out.print(((pa*rec(1,0,k,1))%mod*m)%mod);
         }
    }
    static class InputReader {
        BufferedReader br;
        StringTokenizer st;
        public InputReader(InputStream stream) {
            br = new BufferedReader(new InputStreamReader(stream));
            st = null;
        }

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

        boolean hasMoreTokens() {
            while (st == null || !st.hasMoreTokens()) {
                String s = null;
                try {
                    s = br.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (s == null)
                    return false;
                st = new StringTokenizer(s);
            }
            return true;
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }
        public long nextLong() {
            return Long.parseLong(next());
        }
        public double nextDouble() {
            return Double.parseDouble(next());
        }
    }
}

import java.io.*;
import java.math.BigInteger;
import java.util.*;

public class A {
    private FastScanner in;
    private PrintWriter out;

    void solve() {
        int k = in.nextInt();
        int pa = in.nextInt();
        int pb = in.nextInt();
        final int mod = (int) 1e9 + 7;
        BigInteger MOD = BigInteger.valueOf(mod);
        int inv = BigInteger.valueOf(pa + pb).modInverse(MOD).intValue();
        pa = (int) ((pa * 1L * inv) % mod);
        pb = (int) ((pb * 1L * inv) % mod);
        int[][] dp = new int[k + 1][k];
        dp[1][0] = 1;
        long res = 0;
        int sInv = BigInteger.valueOf(mod - pa + 1).modInverse(MOD).intValue();
        for (int cntA = 0; cntA <= k; cntA++) {
            for (int curK = 0; curK < k; curK++) {
                int pr = dp[cntA][curK];
                if (pr == 0) {
                    continue;
                }
                if (cntA != k) {
                    dp[cntA + 1][curK] = (int) ((dp[cntA + 1][curK] + pr * 1L * pa) % mod);
                } else {
                    int tmpPR = (int) (pr * 1L * pa % mod);
                    res += tmpPR * curK % mod;
                    tmpPR = (int) (tmpPR * 1L * pb % mod);
                    res += cntA * 1L * sInv % mod * tmpPR % mod;
                    res += sInv * 1L * sInv % mod * tmpPR % mod;
                    res %= mod;
                }
                if (curK + cntA >= k) {
                    res = (res + pr * 1L * pb % mod * (curK + cntA)) % mod;
//                    System.err.println("add " + res);
                } else {
                    dp[cntA][curK + cntA] = (int) ((dp[cntA][curK + cntA] + pr * 1L * pb) % mod);
                }
            }
        }
        out.println(res % mod);
    }

    private void run() {
        try {
            in = new FastScanner(new File("A.in"));
            out = new PrintWriter(new File("A.out"));

            solve();

            out.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }

    private void runIO() {
        in = new FastScanner(System.in);
        out = new PrintWriter(System.out);

        solve();

        out.close();
    }

    private class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        FastScanner(File f) {
            try {
                br = new BufferedReader(new FileReader(f));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }

        FastScanner(InputStream f) {
            br = new BufferedReader(new InputStreamReader(f));
        }

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

        boolean hasMoreTokens() {
            while (st == null || !st.hasMoreTokens()) {
                String s = null;
                try {
                    s = br.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (s == null)
                    return false;
                st = new StringTokenizer(s);
            }
            return true;
        }

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

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

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

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

//Why is this a DP problem?
//1. Easy to get from one case to next: each b adds #(a) subsequences of ab.
//2. Math problem w/ no direct way to compute, e.g. NOIP 2013, 900D. But if we know the #ab, #a, it's super easy.
//2.1. In particular, if I can't find an explicit formula, try DP b/c I'm good at math.
import java.util.*;

public class TaskD
{
    private static long P = (long) 1e9+7;
    public static long inverse (long a)
    {
        long m = P, t, q;
        long x0 = 0, x1 = 1;

        while (a > 1)
        {
            q = a / m;
            t = m;
            // process same as Euclid's algo
            m = a % m; a = t;
            t = x0;
            x0 = x1 - q * x0;
            x1 = t;
        }
        // Make x1 positive
        if (x1 < 0) x1 += P;
        return x1;
    }

    public static void main(String[] args) {
        Scanner f = new Scanner(System.in);
        int k = f.nextInt(), pa = f.nextInt(), pb = f.nextInt();
        long[][] e = new long[2*k][2*k];
        for (int i = 2*k-1; i >= 1; i--){
            for (int j = 2*k-1; j >= 0; j--) {
                if (i + j >= k) e[i][j] = (i + j + pa * inverse(pb)) % P;
                else e[i][j] = ((pa * e[i+1][j] + pb * e[i][i+j]) * inverse(pa+pb)) % P;
            }
        }
        System.out.println(e[1][0]);
    }
}