You are given two integers x and y. You can perform two types of operations: 

  1. Pay a dollars and increase or decrease any of these integers by 1. For example, if x = 0 and y = 7 there are four possible outcomes after this operation: 
    * x = 0, y = 6; 
    * x = 0, y = 8; 
    * x = -1, y = 7; 
    * x = 1, y = 7. 

  2. Pay b dollars and increase or decrease both integers by 1. For example, if x = 0 and y = 7 there are two possible outcomes after this operation: 
    * x = -1, y = 6; 
    * x = 1, y = 8. 



Your goal is to make both given integers equal zero simultaneously, i.e. x = y = 0. There are no other requirements. In particular, it is possible to move from x=1, y=0 to x=y=0.

Calculate the minimum amount of dollars you have to spend on it.

Input

The first line contains one integer t (1 ≤ t ≤ 100) — the number of testcases.

The first line of each test case contains two integers x and y (0 ≤ x, y ≤ 10^9).

The second line of each test case contains two integers a and b (1 ≤ a, b ≤ 10^9).

Output

For each test case print one integer — the minimum amount of dollars you have to spend.

Example

Input


2
1 3
391 555
0 0
9 4


Output


1337
0

Note

In the first test case you can perform the following sequence of operations: first, second, first. This way you spend 391 + 555 + 391 = 1337 dollars.

In the second test case both integers are equal to zero initially, so you dont' have to spend money.


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

import static java.lang.Math.*;

public class Contest1 {
    public static class pair implements Comparable<pair> {
        int u;
        long val;

        public pair(int a, long value) {
            u = a;
            val = value;
        }

        @Override
        public int compareTo(pair p) {
            return Long.compare(val, p.val);
        }
    }

    static int n, m;
    static ArrayList<Integer>[] adj;
    static int dist[];
    static int parent[];
    static long inf = (long) 1e16;
    static int INF = (int) 1e9;

    public static int[] bfs(int s) {
        dist = new int[n];
        Arrays.fill(dist, -1);
        dist[s] = 0;
        Queue<Integer> q = new LinkedList<>();
        q.add(s);
        while (!q.isEmpty()) {
            int u = q.poll();
            for (int v : adj[u])
                if (dist[v] == -1) {
                    dist[v] = dist[u] + 1;
                    q.add(v);
                }
        }
        return dist;
    }

    public static long calc(long[] acc, int single, int Dbl) {
        if (single + Dbl > m) return inf;
        return acc[Dbl] + acc[single + Dbl];
    }

    public static boolean subset(TreeSet<Integer> small, TreeSet<Integer> big) {
        for (int x : small)
            if (!big.contains(x))
                return false;
        return true;
    }

    public static TreeSet<Integer> subset2(TreeSet<Integer> small, TreeSet<Integer> big) {
        TreeSet<Integer> ts = new TreeSet<>();
        for (int x : small)
            if (!big.contains(x))
                ts.add(x);
        return ts;
    }

    public static boolean CanBeStart(int x, TreeSet<Integer>[] Arr) {
        TreeSet<Integer> last = new TreeSet<>();
        for (int j = 0; j < n - 1; j++)
            if (Arr[j].contains(x)) {
                if (!subset(last, Arr[j]))
                    return false;
                last = Arr[j];
            }
        return true;
    }

    public static boolean check(TreeSet<Integer> sublist, ArrayList<Integer> arr) {
        int len = sublist.size(), n = arr.size();
        for (int i = 0; i < n - len + 1; i++) {
            boolean flag = true;
            for (int j = 0; j < len; j++)
                if (!sublist.contains(arr.get(i + j)))
                    flag = false;
            if (flag) return true;
        }
        return false;
    }

    public static boolean check(TreeSet<Integer>[] Arr, ArrayList<Integer> arr) {
        boolean ans = true;
        for (int i = 0; i < n - 1; i++)
            ans &= check(Arr[i], arr);
        return ans;
    }

    public static boolean alltrue(boolean[] arr) {
        for (boolean flag : arr)
            if (flag) return false;
        return true;
    }

    public static boolean sep(boolean[] arr) {
        boolean open = false;
        int cnt = 0;
        for (int i = 0; i < arr.length; i++)
            if (open) {
                if (!arr[i]) open = false;
            } else {
                if (arr[i]) {
                    open = true;
                    cnt++;
                }
            }
        return cnt <= 1;
    }


    static int[] dx = new int[]{-1, 1, 0, 0};
    static int[] dy = new int[]{0, 0, -1, 1};
    static boolean[][] Matrix, vis;

    static boolean valid(int i, int j) {
        return i != -1 && j != -1 && i != n && j != m && Matrix[i][j];
    }

    static void dfs2(int i, int j) {
        vis[i][j] = true;                        //mark as visited
        for (int k = 0; k < 4; ++k) {
            int x = i + dx[k], y = j + dy[k];
            if (valid(x, y) && !vis[x][y])
                dfs2(x, y);
        }
    }

    public static boolean isSimilar(char[] Arr, int s, int k) {
        for (int i = s; i < k - 1; i++) {
            if (Arr[i + 1] != Arr[i])
                return false;
        }
        return true;
    }

    public static int ciel(int d, int mod) {
        if (d % mod == 0)
            return d / mod;
        return d / mod + 1;
    }

    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(System.in);
        PrintWriter pw = new PrintWriter(System.out);
        int t = sc.nextInt();
        while (t-- >0) {
            int x = sc.nextInt();
            int y = sc.nextInt();
            int a=sc.nextInt();
            int b=sc.nextInt();
            int max=max(x,y);
            int min=min(x,y);
           long ans=max-min;
            ans*=a;
            if(b>2*a){
                ans+=2*1l*a*min;
            }else{
                ans+=1l*b*min;
            }
            pw.println(ans);
        }

        pw.close();

    }

    static class Scanner {
        StringTokenizer st;
        BufferedReader br;

        public Scanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(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, IOException {
            return br.ready();
        }

    }
}
