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.*;
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 {
        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.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.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.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.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.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]);
    }
}