def sieves(nn: int):
    is_prime = [True] * nn
    least_p = [-1] * nn
    is_prime[0] = is_prime[1] = False
    least_p[1] = 1
    mobius = [1] * nn
    mobius[0] = 0
    for p in range(2, nn):
        if not is_prime[p]:
            continue
        least_p[p] = p
        mobius[p] = -1
        for q in range(p * 2, nn, p):
            is_prime[q] = False
            if least_p[q] == -1:
                least_p[q] = p
            if q % (p * p) == 0:
                mobius[q] = 0
            else:
                mobius[q] *= -1
    primes = [p for p in range(2, nn) if is_prime[p]]
    return is_prime, least_p, primes, mobius

def prime_factorize(n: int):
    ans = {}
    while n > 1:
        p = least_p[n]
        e = 0
        while n % p == 0:
            n //= p
            e += 1
        ans[p] = e
    return ans

def get_divisors(n: int):
    """正の約数列挙

    Args:
        n (int): 約数を求める数 (>= 1)

    Returns:
        list[int]: `n`の正の約数

    Notes:
        - `n`の約数の個数をσ(n)として
        - 計算量 Θ( σ(n) * log(σ(n)) )
        - n <= 10^7 で σ(n) <= σ(8648640) = 448
        - n <= 10^9 で σ(n) <= σ(735134400) = 1344
        - n <= 10^18 で σ(n) <= σ(897612484786617600) = 103680
    """
    pe = prime_factorize(n)
    ans = [1]
    for p, e in pe.items():
        exps = [p ** ei for ei in range(1, e + 1)]
        ans.extend([d * f for d in ans for f in exps])
    ans.sort()
    return ans

is_prime, least_p, primes, mobius = sieves(32000 + 1)
mod = 1_000_000_007

def solve():
    n = int(input())
    from collections import defaultdict, deque
    cgs = defaultdict(list)
    for _ in range(n):
        x, y = map(lambda s_: int(s_), input().split())
        for p in primes:
            if y % p:
                continue
            pe = 1
            while y % p == 0:
                y //= p
                pe *= p
            cgs[p].append((x % pe, pe))
        if y > 1:
            cgs[y].append((x % y, y))
    cgl = [(0, 1)]
    for p, l in cgs.items():
        i = max(range(len(l)), key=lambda i: l[i][1])
        rm, pem = l[i]
        if any(rm % pe != r for r, pe in l):
            return -1
        cgl.append((rm, pem))
    cgq = deque(sorted(cgl, key=lambda t: t[1]))
    while len(cgq) > 1:
        r1, m1 = cgq.popleft()
        r2, m2 = cgq.popleft()
        m3 = m1 * m2
        r3 = r1 + (r2 - r1) * pow(m1, -1, m2) % m3 * m1 % m3
        r3 %= m3
        cgq.append((r3, m3))
    x, y = cgq.popleft()
    if x == 0:
        x = y
    return x % mod


case_t = 1
# case_t = int(input())
for _ in [None] * case_t:
    print(solve())