package main

import (
	"bufio"
	"bytes"
	"io"
	"os"
	"strconv"
)

type FastScanner struct {
	data []byte
	idx  int
}

func NewFastScanner() *FastScanner {
	data, _ := io.ReadAll(os.Stdin)
	return &FastScanner{data: data}
}

func (fs *FastScanner) NextInt() int {
	n := len(fs.data)
	for fs.idx < n && fs.data[fs.idx] <= ' ' {
		fs.idx++
	}
	sign := 1
	if fs.idx < n && fs.data[fs.idx] == '-' {
		sign = -1
		fs.idx++
	}
	val := 0
	for fs.idx < n {
		c := fs.data[fs.idx]
		if c < '0' || c > '9' {
			break
		}
		val = val*10 + int(c-'0')
		fs.idx++
	}
	return val * sign
}

type Seg struct {
	l, r int
	x, y int
}

func gcd(a, b int) int {
	for b != 0 {
		a, b = b, a%b
	}
	if a < 0 {
		return -a
	}
	return a
}

func main() {
	fs := NewFastScanner()
	t := fs.NextInt()
	var out bytes.Buffer

	for ; t > 0; t-- {
		n := fs.NextInt()
		a := make([]int, n+1)
		b := make([]int, n+1)
		for i := 1; i <= n; i++ {
			a[i] = fs.NextInt()
		}
		for i := 1; i <= n; i++ {
			b[i] = fs.NextInt()
		}

		pa := make([]int, n+1)
		pb := make([]int, n+1)
		for i := 1; i <= n; i++ {
			pa[i] = gcd(pa[i-1], a[i])
			pb[i] = gcd(pb[i-1], b[i])
		}

		sa := make([]int, n+2)
		sb := make([]int, n+2)
		for i := n; i >= 1; i-- {
			sa[i] = gcd(sa[i+1], a[i])
			sb[i] = gcd(sb[i+1], b[i])
		}

		pref := make([]Seg, 0, 128)
		start := 1
		curX, curY := pa[0], pb[0]
		for l := 2; l <= n; l++ {
			x, y := pa[l-1], pb[l-1]
			if x != curX || y != curY {
				pref = append(pref, Seg{start, l - 1, curX, curY})
				start = l
				curX, curY = x, y
			}
		}
		pref = append(pref, Seg{start, n, curX, curY})

		prev := make([]Seg, 0, 128)
		tmp := make([]Seg, 0, 128)
		g1 := make([]int, len(pref))
		g2 := make([]int, len(pref))

		best := int64(-1)
		ways := int64(0)

		for r := 1; r <= n; r++ {
			tmp = tmp[:0]
			ar, br := a[r], b[r]

			for _, s := range prev {
				x := gcd(s.x, ar)
				y := gcd(s.y, br)
				m := len(tmp)
				if m > 0 && tmp[m-1].x == x && tmp[m-1].y == y && tmp[m-1].r+1 == s.l {
					tmp[m-1].r = s.r
				} else {
					tmp = append(tmp, Seg{s.l, s.r, x, y})
				}
			}

			m := len(tmp)
			if m > 0 && tmp[m-1].x == ar && tmp[m-1].y == br && tmp[m-1].r+1 == r {
				tmp[m-1].r = r
			} else {
				tmp = append(tmp, Seg{r, r, ar, br})
			}

			tailA := sa[r+1]
			tailB := sb[r+1]
			for i := 0; i < len(pref); i++ {
				g1[i] = gcd(pref[i].x, tailA)
				g2[i] = gcd(pref[i].y, tailB)
			}

			i, p := 0, 0
			for i < len(tmp) && p < len(pref) {
				c := tmp[i]
				pr := pref[p]

				if pr.r < c.l {
					p++
					continue
				}
				if c.r < pr.l {
					i++
					continue
				}

				l := c.l
				if pr.l > l {
					l = pr.l
				}
				rr := c.r
				if pr.r < rr {
					rr = pr.r
				}

				val := int64(gcd(g1[p], c.y) + gcd(g2[p], c.x))
				cnt := int64(rr - l + 1)

				if val > best {
					best = val
					ways = cnt
				} else if val == best {
					ways += cnt
				}

				if c.r < pr.r {
					i++
				} else if c.r > pr.r {
					p++
				} else {
					i++
					p++
				}
			}

			prev, tmp = tmp, prev
		}

		out.WriteString(strconv.FormatInt(best, 10))
		out.WriteByte(' ')
		out.WriteString(strconv.FormatInt(ways, 10))
		out.WriteByte('\n')
	}

	w := bufio.NewWriterSize(os.Stdout, 1<<20)
	w.Write(out.Bytes())
	w.Flush()
}