```go
package main

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

type factor struct {
	p int64
	e int
}

func factorize(n int64) []factor {
	res := make([]factor, 0)
	if n%2 == 0 {
		cnt := 0
		for n%2 == 0 {
			n /= 2
			cnt++
		}
		res = append(res, factor{2, cnt})
	}
	var i int64 = 3
	for i*i <= n {
		if n%i == 0 {
			cnt := 0
			for n%i == 0 {
				n /= i
				cnt++
			}
			res = append(res, factor{i, cnt})
		}
		i += 2
	}
	if n > 1 {
		res = append(res, factor{n, 1})
	}
	return res
}

func genDivs(factors []factor) []int64 {
	divs := []int64{1}
	for _, f := range factors {
		newDivs := make([]int64, 0, len(divs)*(f.e+1))
		pow := int64(1)
		for e := 0; e <= f.e; e++ {
			for _, v := range divs {
				newDivs = append(newDivs, v*pow)
			}
			pow *= f.p
		}
		divs = newDivs
	}
	return divs
}

func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	var t int
	fmt.Fscan(in, &t)
	for ; t > 0; t-- {
		var a, b, c, d int64
		fmt.Fscan(in, &a, &b, &c, &d)

		fa := factorize(a)
		fb := factorize(b)
		da := genDivs(fa)
		db := genDivs(fb)

		found := false
	outer:
		for _, d1 := range da {
			baseA := a / d1
			for _, d2 := range db {
				dmul := d1 * d2
				kx := c / dmul
				x := kx * dmul
				if x <= a {
					continue
				}
				L := baseA * (b / d2)
				kyMax := d / L
				kyMin := b / L
				if kyMax > kyMin {
					y := kyMax * L
					fmt.Fprintln(out, x, y)
					found = true
					break outer
				}
			}
		}
		if !found {
			fmt.Fprintln(out, -1, -1)
		}
	}
}
```