Problem:
Score : 200 points

Problem Statement

We ask you to select some number of positive integers, and calculate the sum of them.

It is allowed to select as many integers as you like, and as large integers as you wish.
You have to follow these, however: each selected integer needs to be a multiple of A, and you need to select at least one integer.

Your objective is to make the sum congruent to C modulo B.
Determine whether this is possible.

If the objective is achievable, print YES. Otherwise, print NO.

Constraints

1 ≤ A ≤ 100

1 ≤ B ≤ 100

0 ≤ C < B

Input

Input is given from Standard Input in the following format:

A B C

Output

Print YES or NO.

Sample Input 1

7 5 1

Sample Output 1

YES

For example, if you select 7 and 14, the sum 21 is congruent to 1 modulo 5.

Sample Input 2

2 2 1

Sample Output 2

NO

The sum of even numbers, no matter how many, is never odd.

Sample Input 3

1 100 97

Sample Output 3

YES

You can select 97, since you may select multiples of 1, that is, all integers.

Sample Input 4

40 98 58

Sample Output 4

YES

Sample Input 5

77 42 36

Sample Output 5

NO

Solution in Rust (1.15.1) (judge verdict: Accepted)

use std::ops::Range;

#[derive(Clone, Debug)]
pub struct Scan2<I, St, F> {
    iter: I,
    f: F,
    state: St,
}

impl<I, St, F> Scan2<I, St, F> {
    fn new(iter: I, state: St, f: F) -> Scan2<I, St, F> {
        Scan2 { iter: iter, state: state, f: f }
    }
}

impl<I, St, F> Iterator for Scan2<I, St, F>
where
    I: Iterator,
    F: Fn(&St, I::Item) -> St,
    St: Clone,
{
    type Item = St;

    #[inline]
    fn next(&mut self) -> Option<St> {
        let o = self.iter.next();
        if let Some(a) = o {
            self.state = (self.f)(&self.state, a);
            Some(self.state.clone())
        } else {
            None
        }
    }
}

trait Iterator2 {
    type Item;

    fn scan2<St, F>(self, initial_state: St, f: F) -> Scan2<Self, St, F>
    where
        F: Fn(&St, Self::Item) -> St,
        Self: std::marker::Sized,
    {
        Scan2::new(self, initial_state, f)
    }
}

impl<T> Iterator2 for Range<T> {
    type Item = T;
}

fn solve(a: i32, b: i32, c: i32) -> bool {
    (0..b).scan2(a % b, |&s, _| (s + a) % b).any(|x| x == c)
}

fn main() {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    let mut iter = s.split_whitespace().map(|w| w.trim().parse().ok().unwrap());
    let a = iter.next().unwrap();
    let b = iter.next().unwrap();
    let c = iter.next().unwrap();
    let ans = solve(a, b, c);
    println!("{}", if ans { "YES" } else { "NO" });
}