package main

import (
	"bufio"
	"fmt"
	"os"
)

func gcd(a, b int64) int64 {
	for b != 0 {
		a, b = b, a%b
	}
	return a
}

func mod(a, m int64) int64 {
	res := a % m
	if res < 0 {
		res += m
	}
	return res
}

func find_first(A, M, U, V int64) int64 {
	if U == 0 {
		return 0
	}
	if A == 0 {
		return -1
	}
	k := (U + A - 1) / A
	if k*A <= V {
		return k
	}

	U_prime := A - (V % A)
	V_prime := A - (U % A)

	y := find_first(M%A, A, U_prime, V_prime)
	if y == -1 {
		return -1
	}

	rem := mod(-y*M-U, A)
	Z := U + rem
	return (y*M + Z) / A
}

func solve_interval(A, M, U, V, L, R int64) int64 {
	A = A % M
	C := mod(A*L, M)
	U_shift := mod(U-C, M)
	V_shift := mod(V-C, M)

	var t int64
	if U_shift <= V_shift {
		t = find_first(A, M, U_shift, V_shift)
	} else {
		t = 0
	}

	if t != -1 && t <= R-L {
		return L + t
	}
	return -1
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)

	readInt64 := func() int64 {
		if !scanner.Scan() {
			return 0
		}
		var res int64
		for _, c := range scanner.Bytes() {
			res = res*10 + int64(c-'0')
		}
		return res
	}

	t := int(readInt64())

	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	for i := 0; i < t; i++ {
		a := readInt64()
		b := readInt64()
		p := readInt64()
		q := readInt64()

		g := gcd(p, q)
		P := p / g
		Q := q / g

		A := 2 * P
		M := 2 * Q

		low := int64(0)
		high := Q
		ans_x := int64(-1)

		for low <= high {
			mid := low + (high-low)/2
			U := Q - mid
			V := Q + mid
			if V >= M {
				V = M - 1
			}
			if U < 0 {
				U = 0
			}

			x := solve_interval(A, M, U, V, a, b)
			if x != -1 {
				ans_x = x
				high = mid - 1
			} else {
				low = mid + 1
			}
		}

		fmt.Fprintf(writer, "%d\n", ans_x)
	}
}