output_description: Print `YES` or `NO`.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      A B C
attempt: from heapq import heappush, heappop, heapify
  from collections import deque, defaultdict, Counter
  from itertools import permutations, combinations, groupby
  import sys, bisect, string, math, time, functools, random
  
  
  def Golf():
      (*a,) = map(int, open(0))
  
  
  def I():
      return int(input())
  
  
  def S_():
      return input()
  
  
  def IS():
      return input().split()
  
  
  def LS():
      return [i for i in input().split()]
  
  
  def LI():
      return [int(i) for i in input().split()]
  
  
  def LI_():
      return [int(i) - 1 for i in input().split()]
  
  
  def NI(n):
      return [int(input()) for i in range(n)]
  
  
  def NI_(n):
      return [int(input()) - 1 for i in range(n)]
  
  
  def StoLI():
      return [ord(i) - 97 for i in input()]
  
  
  def ItoS(n):
      return chr(n + 97)
  
  
  def LtoS(ls):
      return "".join([chr(i + 97) for i in ls])
  
  
  def GI(V, E, Directed=False, index=0):
      org_inp = []
      g = [[] for i in range(n)]
      for i in range(E):
          inp = LI()
          org_inp.append(inp)
          if index == 0:
              inp[0] -= 1
              inp[1] -= 1
          if len(inp) == 2:
              a, b = inp
              g[a].append(b)
              if not Directed:
                  g[b].append(a)
          elif len(inp) == 3:
              a, b, c = inp
              aa = (inp[0], inp[2])
              bb = (inp[1], inp[2])
              g[a].append(bb)
              if not Directed:
                  g[b].append(aa)
      return g, org_inp
  
  
  def GGI(h, w, boundary=1, search=[], replacement_of_found=".", mp_def={"#": 1, ".": 0}):
      # h,w,g,sg=GGI(h,w,boundary=1,search=['S','G'],replacement_of_found='.',mp_def={'#':1,'.':0}) # sample usage
      mp = [boundary] * (w + 2)
      found = {}
      for i in range(h):
          s = input()
          for char in search:
              if char in s:
                  found[char] = (i + 1) * (w + 2) + s.index(char) + 1
                  mp_def[char] = mp_def[replacement_of_found]
          mp += [boundary] + [mp_def[j] for j in s] + [boundary]
      mp += [boundary] * (w + 2)
      return h + 2, w + 2, mp, found
  
  
  def TI(n):
      return GI(n, n - 1)
  
  
  def bit_combination(k, n=2):
      return [[tb // (n**bt) % n for bt in range(k)] for tb in range(n**k)]
  
  
  def show(*inp, end="\n"):
      if show_flg:
          print(*inp, end=end)
  
  
  def show2d(g, h, w):
      for i in range(h):
          show(g[i * w : i * w + w])
  
  
  YN = ["YES", "NO"]
  Yn = ["Yes", "No"]
  mo = 10**9 + 7
  inf = float("inf")
  l_alp = string.ascii_lowercase
  # sys.setrecursionlimit(10**7)
  input = lambda: sys.stdin.readline().rstrip()
  
  show_flg = False
  show_flg = True
  
  a, b, c = LI()
  d = math.gcd(a, b)
  print(YN[c % d != 0])
  
problem_description: 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`.
samples: [{"input": "7 5 1", "output": "YES\n    \n\nFor example, if you select 7 and 14, the sum 21 is congruent to 1 modulo 5.\n\n* * *"}, {"input": "2 2 1", "output": "NO\n    \n\nThe sum of even numbers, no matter how many, is never odd.\n\n* * *"}, {"input": "1 100 97", "output": "YES\n    \n\nYou can select 97, since you may select multiples of 1, that is, all integers.\n\n* * *"}, {"input": "40 98 58", "output": "YES\n    \n\n* * *"}, {"input": "77 42 36", "output": "NO"}]