Problem: Only T milliseconds left before the start of well-known online programming contest Codehorses Round 2017.

Polycarp needs to download B++ compiler to take part in the contest. The size of the file is f bytes.

Polycarp's internet tariff allows to download data at the rate of one byte per t0 milliseconds. This tariff is already prepaid, and its use does not incur any expense for Polycarp. In addition, the Internet service provider offers two additional packages:

  * download a1 bytes at the rate of one byte per t1 milliseconds, paying p1 burles for the package; 
  * download a2 bytes at the rate of one byte per t2 milliseconds, paying p2 burles for the package. 



Polycarp can buy any package many times. When buying a package, its price (p1 or p2) is prepaid before usage. Once a package is bought it replaces the regular tariff until package data limit is completely used. After a package is consumed Polycarp can immediately buy a new package or switch to the regular tariff without loosing any time. While a package is in use Polycarp can't buy another package or switch back to the regular internet tariff.

Find the minimum amount of money Polycarp has to spend to download an f bytes file no more than in T milliseconds.

Note that because of technical reasons Polycarp can download only integer number of bytes using regular tariff and both packages. I.e. in each of three downloading modes the number of downloaded bytes will be integer. It means that Polycarp can't download a byte partially using the regular tariff or/and both packages.

Input

The first line contains three integer numbers f, T and t0 (1 ≤ f, T, t0 ≤ 107) — size of the file to download (in bytes), maximal time to download the file (in milliseconds) and number of milliseconds to download one byte using the regular internet tariff.

The second line contains a description of the first additional package. The line contains three integer numbers a1, t1 and p1 (1 ≤ a1, t1, p1 ≤ 107), where a1 is maximal sizes of downloaded data (in bytes), t1 is time to download one byte (in milliseconds), p1 is price of the package (in burles).

The third line contains a description of the second additional package. The line contains three integer numbers a2, t2 and p2 (1 ≤ a2, t2, p2 ≤ 107), where a2 is maximal sizes of downloaded data (in bytes), t2 is time to download one byte (in milliseconds), p2 is price of the package (in burles).

Polycarp can buy any package many times. Once package is bought it replaces the regular tariff until package data limit is completely used. While a package is in use Polycarp can't buy another package or switch back to the regular internet tariff.

Output

Print the minimum amount of money that Polycarp needs to pay to download B++ compiler no more than in T milliseconds. If there is no solution, print the only integer -1.

Examples

Input

120 964 20
26 8 8
13 10 4


Output

40


Input

10 200 20
1 1 1
2 2 3


Output

0


Input

8 81 11
4 10 16
3 10 12


Output

28


Input

8 79 11
4 10 16
3 10 12


Output

-1

Note

In the first example Polycarp has to buy the first additional package 5 times and do not buy the second additional package. He downloads 120 bytes (of total 26·5 = 130 bytes) in 120·8 = 960 milliseconds (960 ≤ 964). He spends 8·5 = 40 burles on it.

In the second example Polycarp has enough time to download 10 bytes. It takes 10·20 = 200 milliseconds which equals to upper constraint on download time.

In the third example Polycarp has to buy one first additional package and one second additional package.

In the fourth example Polycarp has no way to download the file on time.

Solution (in JAVA):

Solution:
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);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskC {
        final long infinity = Long.MAX_VALUE / 3;
        FastScanner in;

        public void solve(int testNumber, FastScanner in, PrintWriter out) {
            this.in = in;
            long bytesLeft0 = assertedNextInt();
            long timeLeft0 = assertedNextInt();
            long t0 = assertedNextInt();

            long a1 = assertedNextInt();
            long t1 = assertedNextInt();
            long p1 = assertedNextInt();

            long a2 = assertedNextInt();
            long t2 = assertedNextInt();
            long p2 = assertedNextInt();
            long u = solve(bytesLeft0, timeLeft0, t0, a1, t1, p1, a2, t2, p2);
            long v = solve(bytesLeft0, timeLeft0, t0, a2, t2, p2, a1, t1, p1);
            long ans = Math.min(u, v);
            if (ans >= infinity) {
                ans = -1;
            }
            out.println(ans);
        }

        private long solve(long bytesLeft0, long timeLeft0, long t0, long a1, long t1, long p1, long a2, long t2, long p2) {
            final int N = (int) 1e7 + 20;
            long ans = infinity;
            for (int k1 = 0; k1 <= N; k1++) {
                long cost1 = k1 * p1;
                long bytesDownloaded1 = Math.min(bytesLeft0, k1 * a1);
                long time1 = bytesDownloaded1 * t1;
                long bytesLeft1 = bytesLeft0 - bytesDownloaded1;
                long timeLeft1 = timeLeft0 - time1;
                if (timeLeft1 < 0) {
                    continue;
                }
                if (bytesLeft1 == 0) {
                    ans = Math.min(ans, cost1);
                    continue;
                }
                if (t0 * bytesLeft1 <= timeLeft1) {
                    ans = Math.min(ans, cost1);
                    continue;
                }
                if (t0 <= t2) {
                    continue;
                }
                long bytes2 = (bytesLeft1 * t0 - timeLeft1 + (t0 - t2) - 1) / (t0 - t2);
                long k2 = (bytes2 + a2 - 1) / a2;

                long cost2 = k2 * p2;
                long bytesDownloaded2 = Math.min(bytesLeft1, k2 * a2);
                long time2 = bytesDownloaded2 * t2;
                long bytesLeft2 = bytesLeft1 - bytesDownloaded2;
                long timeLeft2 = timeLeft1 - time2;
                if (timeLeft2 >= 0 && bytesLeft2 * t0 <= timeLeft2) {
                    ans = Math.min(ans, cost1 + cost2);
                }
            }
            return ans;
        }

        private long assertedNextInt() {
            long x = in.nextLong();
            if (x < 1 || x > (int) 1e7) {
                throw new AssertionError();
            }
            return x;
        }

    }

    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 {
                    st = new StringTokenizer(in.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return st.nextToken();
        }

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

    }
}