You are an experienced Codeforces user. Today you found out that during your activity on Codeforces you have made y submissions, out of which x have been successful. Thus, your current success rate on Codeforces is equal to x / y.

Your favorite rational number in the [0;1] range is p / q. Now you wonder: what is the smallest number of submissions you have to make if you want your success rate to be p / q?

Input

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

Each of the next t lines contains four integers x, y, p and q (0 ≤ x ≤ y ≤ 109; 0 ≤ p ≤ q ≤ 109; y > 0; q > 0).

It is guaranteed that p / q is an irreducible fraction.

Hacks. For hacks, an additional constraint of t ≤ 5 must be met.

Output

For each test case, output a single integer equal to the smallest number of submissions you have to make if you want your success rate to be equal to your favorite rational number, or -1 if this is impossible to achieve.

Example

Input

4
3 10 1 2
7 14 3 8
20 70 2 7
5 6 1 1


Output

4
10
0
-1

Note

In the first example, you have to make 4 successful submissions. Your success rate will be equal to 7 / 14, or 1 / 2.

In the second example, you have to make 2 successful and 8 unsuccessful submissions. Your success rate will be equal to 9 / 24, or 3 / 8.

In the third example, there is no need to make any new submissions. Your success rate is already equal to 20 / 70, or 2 / 7.

In the fourth example, the only unsuccessful submission breaks your hopes of having the success rate equal to 1.
import java.util.*;
import java.io.*;
import java.lang.*;
import java.security.KeyStore.Entry;
public class Q3 {

	static ArrayList<Integer> adj[];
	static int color[],red[],black[],previs[];
	static boolean b[],visited[],possible;
	static Map<Long,Long> dict;
	static int totalnodes,colored,time,v[],l[],r[];
	static int p[];
	static  HashMap<Long,Long> hm;
	
	void solve(){
	//	long ss = System.currentTimeMillis();
		in=new InputReader(System.in);
		w=new PrintWriter(System.out);
		int t=in.nextInt();
		while(t--!=0)
		{
			int x=in.nextInt();
			int y=in.nextInt();
			int p=in.nextInt();
			int q=in.nextInt();
			
			if(p==0)
			{
				int ans=0;
				if(x==0)
				{
					w.println("0");
				}
				else
					w.println("-1");
				
				continue;
				
			}
			else if(p==q)
			{
				if(x==y)
					w.println("0");
				else
					w.println("-1");
				
				continue;
				
			}
			else
			{
					int t1=(int)(x +p-1)/p;
					int t2=(int)((y-x)+(q-p)-1)/(q-p);
					
					w.println((long)q*(long)Math.max(t1,t2)-y);
			}
			
			
			
			
			
		}
		w.close();
		
				
	}
	long check(long pos,long i,long n)
	{
		
	while(true)
		{
			if(n<2)
				return n;
			if(pos+1==2*i)
				return n%2;
			n/=2;
			pos/=2;
			if(i>pos+1)
				i-=(pos+1);
			
		}

		
	}
	int modularExponentiation(int x,int n,int M)
	{
	    if(n==0)
	        return 1;
	    else if(n%2 == 0)        //n is even
	        return modularExponentiation((x*x)%M,n/2,M);
	    else                             //n is odd
	        return (x*modularExponentiation((x*x)%M,(n-1)/2,M))%M;

	}
/*	void dfs(int u,int low,int high)
	{
		if(u==-1 || low>high)
			return;
		if(low<=v[u] && v[u]<=high){
		hm.put(v[u],true);
		}
		dfs(l[u],low,high<v[u]-1?high:v[u]-1);
		dfs(r[u],low>v[u]+1?low:v[u]+1,high);
		
	}
	
	  int dfs_red(int i)
	{
		previs[i]=time++;
		visited[i]=true;
		if(color[i]==0)
			red[i]++;
		for(int j:adj[i])
		{
			if(!visited[j])
				red[i]+=dfs_red(j);
		}
		return red[i];
	}
	 int dfs_black(int i)
	{
		
		visited[i]=true;
		if(color[i]==1)
			black[i]++;
		for(int j:adj[i])
		{
			if(!visited[j])
				black[i]+=dfs_black(j);
		}
		return black[i];
	}*/
	public static void main(String[] args) throws IOException{
		new Q3().solve();
	}
	
	 public static class dsu
		{
			 
			int n;
			int parent[];
		    int s[];
			dsu(int n)
			{
				this.n=n;
				parent=new int[n+1];
				s=new int[n+1];
		        for(int i=0;i<=n;i++)
		        {
		            parent[i]=i;
		            s[i]=1;
		        }
			}
		 int find(int i)
		{
		    if (parent[i] == i)
		        return i;
		    else
		    {
		    	int result = find(parent[i]);
		        parent[i] = result;
		        return result;
		     }
		}
		}
	static InputReader in;
	static PrintWriter w;
	public boolean oj = System.getProperty("ONLINE_JUDGE") != null;

	public void tr(Object... o) {
		if (!oj)
			System.out.println(Arrays.deepToString(o));
	}

	public static void seive(long n){
		b = new boolean[(int) (n+1)];
		Arrays.fill(b, true);
		for(int i = 2;i*i<=n;i++){
			if(b[i]){
				for(int p = 2*i;p<=n;p+=i){
					b[p] = false;
				}
			}
		}
	}
	public static long power(long a,long b,long c)
	{
		long ans = 1;
		while(b!=0)
		{
			if(b%2==1)
			{
				ans = ans*a;
				ans = ans % c;
			}
			a = a*a;
			a = a%c;
			b = b/2;
		}
		return ans;
	}
	static class Pair implements Comparable<Pair> {
		int u,v,w;
		
		public Pair(){
			
		}
		public Pair(int u,int v) {
			this.u=u;
			this.v=v;
			this.w=Math.min(u, v);
			
		}
		public int compareTo(Pair other) {
			
			int o=Math.min(other.u,other.v)-Math.min(other.u/2, other.v);	
			int p=Math.min(this.u,this.v)-Math.min(this.u/2, this.v);
			return o-p;
		}
		
		/*public String toString() {
			return "[u=" + u + ", v=" + v + "]";
		}*/
	}
	static class Node2{
		Node2 left = null;
		Node2 right = null;
		Node2 parent = null;
		int data;
	}
	
	//binaryStree
	static class BinarySearchTree{
		Node2 root = null;
		int height = 0;
		int max = 0;
		int cnt = 1;
		ArrayList<Integer> parent = new ArrayList<>();
		HashMap<Integer, Integer> hm = new HashMap<>();
		public void insert(int x){
			Node2 n = new Node2();
			n.data = x;
			if(root==null){
				root = n;
			}
			else{
				Node2 temp = root,temp2 = null;
				while(temp!=null){
					temp2 = temp;
					if(x>temp.data) temp = temp.right;
					else temp = temp.left;
				}
				if(x>temp2.data) temp2.right = n;
				else temp2.left = n;
				n.parent = temp2;
				parent.add(temp2.data);
			}
		}
		public Node2 getSomething(int x, int y, Node2 n){
			if(n.data==x || n.data==y) return n;
			else if(n.data>x && n.data<y) return n;
			else if(n.data<x && n.data<y) return getSomething(x,y,n.right);
			else return getSomething(x,y,n.left);
		}
		public Node2 search(int x,Node2 n){
			if(x==n.data){
				max = Math.max(max, n.data);
				return n;
			}
			if(x>n.data){
				max = Math.max(max, n.data);
				return search(x,n.right);
			}
			else{
				max = Math.max(max, n.data);
				return search(x,n.left);
			}
		}
		public int getHeight(Node2 n){
			if(n==null) return 0;
			height = 1+ Math.max(getHeight(n.left), getHeight(n.right));
			return height;
		}
	}
public static void debug(Object... o) {
	System.out.println(Arrays.deepToString(o));
}

public static String rev(String s)
{
	StringBuilder sb=new StringBuilder(s);
	sb.reverse();
	return sb.toString();
}

static long lcm(long a, long b)
{
    return a * (b / gcd(a, b));
}

static long gcd(long a, long b)
{
    while (b > 0)
    {
        long temp = b;
        b = a % b; // % is remainder
        a = temp;
    }
    return a;
}

public static long max(long x, long y, long z){
		if(x>=y && x>=z) return x;
		if(y>=x && y>=z) return y;
		return z;
	}
	static int[] sieve(int n,int[] arr)
	{
	for(int i=2;i*i<=n;i++)
	{
		if(arr[i]==0)
		{
			for(int j=i*2;j<=n;j+=i)
				arr[j]=1;
		}
	}
	return arr;
	}




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) {
	 return nextIntArray(n, 0);
	    }
	    
public int[] nextIntArray(int n, int off) {
	 int[] arr = new int[n + off];
	   for (int i = 0; i < n; i++) {
	    arr[i + off] = nextInt();
	    }
	    return arr;
	    }
	    
public long[] nextLongArray(int n) {
return nextLongArray(n, 0);
	    }
        
	public long[] nextLongArray(int n, int off) {
	 long[] arr = new long[n + off];
	 for (int i = 0; i < n; i++) {
		  arr[i + off] = nextLong();
		 }
 return arr;
	}


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);
}
}
	
}
