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.sql.SQLSyntaxErrorException;
import java.util.*;
import java.io.*;
import java.util.stream.StreamSupport;


public class Solution {
    static int mod = 998244353;
    public static void main(String str[]) throws IOException {
//        Reader sc = new Reader();
        BufferedWriter output = new BufferedWriter(new OutputStreamWriter(System.out));
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();

        while(t-->0){
            int p = sc.nextInt();
            int f = sc.nextInt();
            int n1 = sc.nextInt();
            int n2 = sc.nextInt();
            int s = sc.nextInt();
            int w = sc.nextInt();
            int c1 = 0;
            int c2 = 0;
            int small = 0;
            int large = 0;
            if(s<=w){
                small = s;
                c1 = n1;
                large = w;
                c2 = n2;
            }
            else{
                small = w;
                c1 = n2;
                large = s;
                c2 = n1;
            }
            int x1 = p/small;
            int curr1 = 0;
            int curr2 = 0;
            int sc1 = 0;
            int sc2 = 0;
            int lc1 = 0;
            int lc2 = 0;
            if(c1<=x1){
                sc1 = c1;
            }
            else{
                sc1 = x1;
                sc2 = Math.min(c1-x1, f/small);
            }
            int ans = 0;
            do{
                lc1 = Math.min((p-sc1*small)/large,c2);
                lc2 = Math.min(c2-lc1, (f-sc2*small)/large);
                ans = Math.max(ans, sc1+sc2+lc1+lc2);
                sc1--;
                sc2++;
                if(sc2*small>f) break;
            }while(sc1>=0);
            System.out.println(ans);
        }

        output.flush();
    }


    // Returns n^(-1) mod p
    static int modInverse(long n, long p)
    {
        return (int)power(n, p - 2, p);
    }

    // Returns nCr % p using Fermat's
    // little theorem.
    static long nCrModPFermat(int n, int r,
                              int p, long[] fac)
    {

        if (n<r)
            return 0;
        // Base case
        if (r == 0)
            return 1;

        // Fill factorial array so that we
        // can find all factorial of r, n
        // and n-r
        long x = modInverse(fac[r], p);
        long y = modInverse(fac[n - r], p);

        return (fac[n] * x
                % p * y
                % p)
                % p;
    }
    static long[] sum(String[] str){
        int n = str[0].length();
        long ans[] = new long[n];
        for(String s: str){
            for(int i=0;i<n;i++)   ans[i]+=s.charAt(i);
        }
        return ans;
    }

    static class tSort implements Comparator<Pair>{

        public int compare(Pair s1, Pair s2) {
            if (s1.b < s2.b)
                return -1;
            else if (s1.b > s2.b)
                return 1;
            return 0;
        }
    }
    static void dfs2(Tree[] arr, int[] ans,boolean[] vis, int curr){
        Collections.sort(arr[curr].al, new Comparator<Integer>() {
            @Override
            public int compare(Integer a, Integer b)
            {
                if(ans[arr[a].a]==-1)  return 1;
                if(ans[arr[b].a]==-1) return -1;
                if(ans[arr[a].a]>=ans[arr[b].a]) return 1;
                else return -1;
            }
        });
        vis[curr] = true;
        for(int j=0;j<arr[curr].al.size();j++){
            int i = arr[curr].al.get(j);
            if(ans[i]==-1 || ans[curr]==-1) ans[i] = -1;
            else    ans[i] = Math.max(ans[i],ans[curr]);
            if(!vis[i]){
                vis[i] = true;
                dfs2(arr,ans,vis,i);
            }
        }
    }
    static void dfs(Tree[] arr, int[] ans, int curr, int n, int parent){
        if(parent!=-1 && ans[parent]==-1)   ans[curr] = -1;
        for(int i: arr[curr].al){
            if(ans[curr]==-1) ans[i]=-1;
            else    if(ans[i]==0){
                ans[i] = 1;
                dfs(arr,ans,i,n,curr);
            }
            else if(ans[i]==1){
                ans[i] = 2;
                boolean visited[] = new boolean[n];
                if(checkCycle(arr,visited,i, i))   ans[i] = -1;
            }
        }
    }
    static boolean checkCycle(Tree[] arr,  boolean[] visited, int curr, int node){
        if(curr==node && visited[curr]) return true;
        if(visited[curr])   return false;
        visited[curr]  = true;
        for(int i: arr[curr].al){
            if(checkCycle(arr, visited, i, node))    return true;
        }
        return false;
    }


    static ArrayList<String> fun( int curr, int n, char c){
        int len = n-curr;
        if(len==0)  return null;
        ArrayList<String> al = new ArrayList<>();
        if(len==1){
            al.add(c+"");
            return al;
        }
        String ss = "";
        for(int i=0;i<len/2;i++){
            ss+=c;
        }
        ArrayList<String> one = fun(len/2+curr, n, (char)(c+1));
        for(String str: one){
            al.add(str+ss);
            al.add(ss+str);
        }
        return al;
    }
    static ArrayList convert(int x, int k){
        ArrayList<Integer> al = new ArrayList<>();
        if(x>0) {
            while (x > 0) {
                al.add(x % k);
                x /= k;
            }
        }
        else    al.add(0);
        return al;
    }




    static int max(int x, int y, int z){
        int ans = Math.max(x,y);
        ans = Math.max(ans, z);
        return ans;
    }
    static int min(int x, int y, int z){
        int ans = Math.min(x,y);
        ans = Math.min(ans, z);
        return ans;
    }

//    static long treeTraversal(Tree arr[], int parent, int x){
//        long tot = 0;
//        for(int i: arr[x].al){
//            if(i!=parent){
//                tot+=treeTraversal(arr, x, i);
//            }
//        }
//        arr[x].child = tot;
//        if(arr[x].child==0) arr[x].child = 1;
//        return tot+1;
//    }

    public static int primeFactors(int n, int k)
    {
        int ans = 0;

        while (n%2==0)
        {
            ans++;
            if(ans>=k)  return k;
            n /= 2;
        }
        for (int i = 3; i <= Math.sqrt(n); i+= 2)
        {
            while (n%i == 0)
            {
                ans++;
                n /= i;
                if(ans>=k)  return k;
            }
        }

        if (n > 2)  ans++;
        return ans;
    }
    static int binaryLow(ArrayList<Integer> arr, int x, int s, int e){
        if(s>=e){
            if(arr.get(s)>=x)  return s;
            else    return s+1;
        }
        int m = (s+e)/2;
        if(arr.get(m)==x)  return m;
        if(arr.get(m)>x)   return binaryLow(arr,x,s,m);
        if(arr.get(m)<x)   return binaryLow(arr,x,m+1,e);
        return 0;
    }
    static int binaryLow(int[] arr, int x, int s, int e){
        if(s>=e){
            if(arr[s]>=x)  return s;
            else    return s+1;
        }
        int m = (s+e)/2;
        if(arr[m]==x)  return m;
        if(arr[m]>x)   return binaryLow(arr,x,s,m);
        if(arr[m]<x)   return binaryLow(arr,x,m+1,e);
        return 0;
    }
    static int binaryHigh(int[] arr, int x, int s, int e){
        if(s>=e){
            if(arr[s]<=x)  return s;
            else    return s-1;
        }
        int m = (s+e)/2;
        if(arr[m]==x)  return m;
        if(arr[m]>x)   return binaryHigh(arr,x,s,m-1);
        if(arr[m]<x)   return binaryHigh(arr,x,m+1,e);
        return 0;
    }


    static void arri(int arr[], int n, Reader sc) throws IOException{
        for(int i=0;i<n;i++){
            arr[i] = sc.nextInt();
        }
    }
    static void arrl(long arr[], int n, Reader sc) throws IOException{
        for(int i=0;i<n;i++){
            arr[i] = sc.nextLong();
        }
    }

    static long gcd(long a, long b)
    {
        if (b == 0)
            return a;
        return gcd(b, a % b);
    }
    static long power(long x, long y, long p)
    {
        long res = 1; // Initialize result

        x = x % p; // Update x if it is more than or
        // equal to p

        if (x == 0)
            return 0; // In case x is divisible by p;

        while (y > 0)
        {

            // If y is odd, multiply x with result
            if ((y & 1) != 0)
                res = (res * x) % p;

            // y must be even now
            y = y >> 1; // y = y/2
            x = (x * x) % p;
        }
        return res%p;
    }

//    static boolean dfs(Tree node, boolean[] visited, int parent, ArrayList<Tree> tt){
//        visited[node.a] = true;
//        boolean b = false;
//        for(int i: node.al){
//            if(tt.get(i).a!=parent){
//                if(visited[tt.get(i).a])    return true;
//                b|= dfs(tt.get(i), visited, node.a, tt);
//            }
//        }
//        return b;
//    }


    static class Pair{
        //        int ind;
        long a=0;
        long b=0;
        //        ArrayList<Integer> ii = new ArrayList<>();
//        Pair( long a, long b){
////            this.ind = i;
//            this.a = a;
//            this.b = b;
//        }

    }
    //    static class sortT implements Comparator<Integer> {
//        // Used for sorting in ascending order of
//        // roll number
//        public int compare(Integer a, Integer b)
//        {
//            if(a.ans[a.a]==-1)  return 1;
//            if(b.ans[b.a]==-1) return -1;
//            if(a.ans[a.a]>=a.ans[b.a]) return 1;
//            else return -1;
//        }
//    }
    static class SortbyI implements Comparator<Pair> {
        // Used for sorting in ascending order of
        // roll number
        public int compare(Pair a, Pair b)
        {
            if(a.a>=b.a) return 1;
            else return -1;
        }
    }
    static class SortbyD implements Comparator<Pair> {
        // Used for sorting in ascending order of
        // roll number
        public int compare(Pair a, Pair b)
        {
            if(a.a<b.a) return 1;
            else if(a.a==b.b && a.b>b.b)    return 1;
            else return -1;
        }
    }
    static int binarySearch(ArrayList<Pair> a, int x, int s, int e){
        if(s>=e){
            if(x<=a.get(s).b)  return s;
            else    return s+1;
        }
        int mid = (e+s)/2;
        if(a.get(mid).b<x){
            return binarySearch(a, x, mid+1, e);
        }
        else    return binarySearch(a,x,s, mid);
    }

    //    static class Edge{
//        int a;
//        int b;
//        int c;
//        int sec;
//        Edge(int a, int b, int c, int sec){
//            this.a = a;
//            this.b = b;
//            this.c = c;
//            this.sec = sec;
//        }
//
//    }
    static class Tree{
        int a;
        int[] ans;
        ArrayList<Integer> al = new ArrayList<>();
        Tree(int a){
            this.a = a;
        }

    }
    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[64]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1) {
                if (c == '\n') {
                    if (cnt != 0) {
                        break;
                    }
                    else {
                        continue;
                    }
                }
                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();
        }
    }


    static boolean isPrime(int n)
    {
        if (n <= 1)
            return false;
        if (n <= 3)
            return true;
        if (n % 2 == 0 ||
                n % 3 == 0)
            return false;

        for (int i = 5;
             i * i <= n; i = i + 6)
            if (n % i == 0 ||
                    n % (i + 2) == 0)
                return false;

        return true;
    }
    static ArrayList<Integer> sieveOfEratosthenes(int n)
    {
        ArrayList<Integer> al = new ArrayList<>();
        // Create a boolean array
        // "prime[0..n]" and
        // initialize all entries
        // it as true. A value in
        // prime[i] will finally be
        // false if i is Not a
        // prime, else true.
        boolean prime[] = new boolean[n + 1];
        for (int i = 0; i <= n; i++)
            prime[i] = true;

        for (int p = 2; p * p <= n; p++)
        {
            // If prime[p] is not changed, then it is a
            // prime
            if (prime[p] == true)
            {
                // Update all multiples of p
                for (int i = p * p; i <= n; i += p)
                    prime[i] = false;
            }
        }

        // Print all prime numbers
        for (int i = 2; i <= n; i++)
        {
            if (prime[i] == true)
                al.add(i);
        }
        return al;
    }

}







