from sys import stdin
import numpy as np
from numba import njit, i8, i4, f8, b1, i1

read = stdin.buffer.read
rl = stdin.buffer.readline


def from_read(dtype=np.int64) -> np.ndarray:
    return np.fromstring(
        read().decode(),
        dtype=dtype,
        sep=" ",
    )


def from_readline(
    dtype=np.int64,
) -> np.ndarray:
    return np.fromstring(
        rl().decode(),
        dtype=dtype,
        sep=" ",
    )


@njit
def factorize(n):
    f = []
    for i in range(2, n):
        if i * i > n:
            break
        if n % i:
            continue
        e = 0
        while n % i == 0:
            n //= i
            e += 1
        f.append((i, e))
    if n > 1:
        f.append((n, 1))
    return f


@njit
def factorize_lcm(a):
    f = dict()
    for x in a:
        for p, e in factorize(x):
            c = f[p] if p in f else 0
            f[p] = max(c, e)
    return f


@njit
def mpow(m, x, t):
    if t == 0:
        return 1
    y = mpow(m, x, t >> 1)
    y = y * y % m
    if t & 1:
        y = y * x % m
    return y


@njit
def lcm_mod(m, a):
    l = 1
    for p, e in factorize_lcm(a).items():
        l = l * mpow(m, p, e) % m
    return l


@njit
def egcd(a, b):
    if b == 0:
        if a < 0:
            return (-a, -1, 0)
        return a, 1, 0
    q, r = divmod(a, b)
    g, s, t = egcd(b, r)
    return g, t, s - q * t


@njit
def crt_mod(m, r, mod):
    l = m.size
    assert r.size == l
    m = np.append(m, mod)
    p = np.ones(l + 1, np.int64)
    x = np.zeros(l + 1, np.int64)
    for i in range(l):
        n = m[i]
        assert n > 0
        g, ip, _ = egcd(p[i], n)
        q, a = divmod(r[i] - x[i], g)
        if a:
            return -1
        n //= g
        t = q % n * ip % n
        for j in range(i + 1, l + 1):
            x[j] += t * p[j]
            x[j] %= m[j]
            p[j] = p[j] * n % m[j]
    return x[-1]


@njit((i8, i8[:], i8[:]), cache=1)
def solve(n, m, r):
    mod = 10**9 + 7
    if r.max() == 0:
        res = lcm_mod(mod, m)
    else:
        res = crt_mod(m, r, mod)
    return res


def main():
    t = 1
    # t = int(rl())
    for _ in range(t):
        n = int(rl())
        r, m = from_read().reshape(n, 2).T
        ans = solve(n, m, r)
        print(ans)


main()