You are playing one RPG from the 2010s. You are planning to raise your smithing skill, so you need as many resources as possible. So how to get resources? By stealing, of course.

You decided to rob a town's blacksmith and you take a follower with you. You can carry at most p units and your follower — at most f units.

In the blacksmith shop, you found cnt_s swords and cnt_w war axes. Each sword weights s units and each war axe — w units. You don't care what to take, since each of them will melt into one steel ingot.

What is the maximum number of weapons (both swords and war axes) you and your follower can carry out from the shop?

Input

The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases.

The first line of each test case contains two integers p and f (1 ≤ p, f ≤ 10^9) — yours and your follower's capacities.

The second line of each test case contains two integers cnt_s and cnt_w (1 ≤ cnt_s, cnt_w ≤ 2 ⋅ 10^5) — the number of swords and war axes in the shop.

The third line of each test case contains two integers s and w (1 ≤ s, w ≤ 10^9) — the weights of each sword and each war axe.

It's guaranteed that the total number of swords and the total number of war axes in all test cases don't exceed 2 ⋅ 10^5.

Output

For each test case, print the maximum number of weapons (both swords and war axes) you and your follower can carry.

Example

Input


3
33 27
6 10
5 6
100 200
10 10
5 5
1 19
1 3
19 5


Output


11
20
3

Note

In the first test case: 

  * you should take 3 swords and 3 war axes: 3 ⋅ 5 + 3 ⋅ 6 = 33 ≤ 33 
  * and your follower — 3 swords and 2 war axes: 3 ⋅ 5 + 2 ⋅ 6 = 27 ≤ 27. 

3 + 3 + 3 + 2 = 11 weapons in total.

In the second test case, you can take all available weapons even without your follower's help, since 5 ⋅ 10 + 5 ⋅ 10 ≤ 100.

In the third test case, you can't take anything, but your follower can take 3 war axes: 3 ⋅ 5 ≤ 19.
import java.io.*;
import java.util.*;

import java.math.*;

public class Main {

    // static long sx = 0, sy = 0, mod = (long) (998244353);

    static ArrayList<Integer>[] a;
    static ArrayList<Long> p;
    // static Integer[][] dp;
    static HashMap<ArrayList<Integer>, Long> hm = new HashMap<>();
    static boolean[][] vis;
    static int[] farr;
    static long[] far;
    public static PrintWriter out = new PrintWriter(System.out);
    static ArrayList<pair> pa = new ArrayList<>();
    static long[] fact = new long[(int) 1e6];
    static StringBuilder sb = new StringBuilder();
    static boolean cycle = false;
    static long mo = (long) (1e9 + 7);
    // static int[] c, col;
    // static int n = 0, m, x, k;
    // static int ans = Integer.MAX_VALUE;
    static boolean b = true;
    static boolean[] reach = new boolean[6000];
    static int[][] par;
    static int[] depth;
    static int[] size;
    static long[] pow;
    static int time = 0;
    static int[] disc;
    static int[] low;
    static char[][] ch;
    // static int cnt = 0;
    static int[][] dirs = { { -1, 0 }, { 0, 1 }, { 1, 0 }, { 0, -1 }, };
    // static int n = 0, k = 0, z = 0;
    static long[] val;
    static String s1, s2;
    static long x, y;
    static int m = 0;
    static int n;
    static String str;
    static int odd, even;
    static long[] dp;
    static long[] dp1;
    static long[] col;
    static long ans;

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

        // Scanner scn = new Scanner(new BufferedReader(new
        // InputStreamReader(System.in)));

        Reader scn = new Reader();

        int t = scn.nextInt();

        while (t-- != 0) {

            long p = scn.nextLong(), f = scn.nextLong(), cnts = scn.nextLong(), cntw = scn.nextLong();
            long s = scn.nextLong(), w = scn.nextLong();

            long ans = 0;
            
            if(w<s){
                long temp = cnts;
                cnts = cntw;
                cntw = temp;
                
                temp = s;
                s = w;
                w = temp;
            }

            for (int i = 0; i <= cnts && i * s <= p; i++) {

                long ds = Math.min((cnts - i), f / s);

                long mrs = p - (i * s);
                long drs = f - ds * s;

                long tx = Math.min(cntw, mrs / w + drs / w);

                ans = Math.max(ans, tx + i + ds);
            }

            System.out.println(ans);
        }
    }

    // _________________________TEMPLATE_____________________________________________________________

    // public static long lcm(long x, long y) {
    //
    // return (x * y) / gcd(x, y);
    // }
    //
    // private static long gcd(long x, long y) {
    // if (x == 0)
    // return y;
    //
    // return gcd(y % x, x);
    // }

    //
    // static class comp implements Comparator<Integer> {
    //
    // @Override
    // public int compare(Integer p1, Integer p2) {
    //
    // return p2 - p1;
    //
    // }
    // }
    //
    // }
    //
    // public static long pow(long a, long b, long mod) {
    //
    // if (b < 0)
    // return 0;
    // if (b == 0 || b == 1)
    // return (long) Math.pow(a, b);
    //
    // if (b % 2 == 0) {
    //
    // long ret = pow(a, b / 2, mod);
    // ret = (ret % mod * ret % mod) % mod;
    // return ret;
    // }
    //
    // else {
    // return ((pow(a, b - 1, mod) % mod) * a % mod) % mod;
    // }
    // }

    private static class pair implements Comparable<pair> {

        int i;
        int j;
        int cnt;

        pair(int a, int b, int c) {
            i = a;
            j = b;
            cnt = c;
        }

        @Override
        public int compareTo(pair o) {

            return this.cnt - o.cnt;
        }

        // @Override
        //
        // public int hashCode() {
        // return i;
        // }
        //
        // @Override
        //
        // public boolean equals(Object o) {
        //
        // pair p = (pair) o;
        // return this.i == p.i;
        // }

    }

    private static class pair1 {

        int a, b;

        pair1(int a, int b) {
            this.a = a;
            this.b = b;
        }

    }

    private static String reverse(String s) {

        return new StringBuilder(s).reverse().toString();
    }

    public static class Reader {
        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

        public Reader() {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public Reader(String file_name) throws IOException {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public String readLine() throws IOException {
            byte[] buf = new byte[1000000 + 1]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1) {
                if (c == '\n')
                    break;
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }

        public int nextInt() throws IOException {
            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 long nextLong() throws IOException {
            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 double nextDouble() throws IOException {
            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() throws IOException {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }

        public void close() throws IOException {
            if (din == null)
                return;
            din.close();
        }

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

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

        public int[][] nextInt2DArray(int m, int n) throws IOException {
            int[][] arr = new int[m][n];
            for (int i = 0; i < m; i++) {
                for (int j = 0; j < n; j++)
                    arr[i][j] = nextInt();
            }
            return arr;
        }

        public long[][] nextInt2DArrayL(int m, int n) throws IOException {
            long[][] arr = new long[m][n];
            for (int i = 0; i < m; i++) {
                for (int j = 0; j < n; j++)
                    arr[i][j] = nextInt();
            }
            return arr;
        }
        // kickstart - Solution
        // atcoder - Main
    }

}