import math

def modinv(a, mod):
    g, x, y = extended_gcd(a, mod)
    if g != 1:
        return None
    else:
        return x % mod

def extended_gcd(a, b):
    if b == 0:
        return (a, 1, 0)
    else:
        g, x, y = extended_gcd(b, a % b)
        return (g, y, x - (a // b) * y)

def main():
    import sys
    input = sys.stdin.read().split()
    ptr = 0
    N = int(input[ptr])
    ptr += 1
    M = int(input[ptr])
    ptr += 1
    congruences = []
    for _ in range(M):
        B = int(input[ptr])
        C = int(input[ptr + 1])
        ptr += 2
        congruences.append((B, C))
    
    current_a = 0
    current_m = 1
    
    for B, C in congruences:
        # Compute normalized C mod B
        c = (C % B + B) % B
        
        # Merge current_a mod current_m with c mod B
        g = math.gcd(current_m, B)
        if (c - current_a) % g != 0:
            print("NaN")
            return
        
        # Compute LCM
        lcm = current_m // g * B
        
        m_div = current_m // g
        B_div = B // g
        rhs = (c - current_a) // g
        
        inv = modinv(m_div, B_div)
        if inv is None:
            print("NaN")
            return
        
        k = (rhs * inv) % B_div
        new_a = current_a + k * current_m
        current_a = new_a % lcm
        current_m = lcm
    
    if current_a <= N:
        print(current_a)
    else:
        print("NaN")

if __name__ == "__main__":
    main()