/*
 * User: ������
 * Date: 27.02.2016
 * Time: 15:49

������������ ����� �� ����� 128

A. Ҹ���� � �������
����������� �� ������� �� ����   2 �������
����������� �� ������ �� ����   256 ��������
����    ����������� ����
�����   ����������� �����
����� ��������� �� �����������. ����� ������� ��� �������� ���� �����, �� ������� ������ ���������� ��� ���.
� ����� ���� ��� ���������, Ҹ���� � �������, ������ �� ������� ����� ���������� ����� ��������������� ���������� ���������.
������ ����, �������� � ���, ������� a ������ �����, ���� ��� ���� �������� �� Ҹ����� ���������, � b ������ �����, ���� ��� ���� �������� �� ��������.
����� ��������� ���, ����� ������ ������� ����� c ������ �����. ���������, �������� �� ���.
������� ������
� ������ ������ �������� ����� �������� ��� ����� ����� a, b � c (1 <= a, b <= 100, 1 <= c <= 10 000) � ���������� ������ �����,
������� ��������� Ҹ���� � ������� ����������� �� ���� �������, � ���������� ������ �����, ������� ���������� ������� ����, ��������������.
�������� ������
���� ����� ����� ������� ����� c ������ �����, �� �������� �Yes� (��� �������), � ��������� ������ �������� �No� (��� �������).
�������
������� ������
4 6 15
�������� ������
No
������� ������
3 2 7
�������� ������
Yes
������� ������
6 11 6
�������� ������
Yes
����������
�� ������ ������� ����� ����� ��������� 1 ���� �� Ҹ����� ��������� � 2 ���� �� ��������, ����� ������� �� ������ �� ���� 1�3 + 2�2 = 7 ������ �����.

 */

using System;

namespace Edu003A
{
	class Program
	{
		public static void Main(string[] args)
		{
			string ss = Console.ReadLine ();
			string [] s = ss.Split (' ');
			int a = int.Parse (s [0]);
			int b = int.Parse (s [1]);
			int c = int.Parse (s [2]);

			bool ok = false;
			for ( int i=0; i <= c; i++ )
				if ( a*i <= c && (c - a*i) % b == 0 )
				{
					ok = true;
					break;
				}

			if ( ok )
				Console.WriteLine ("Yes");
			else
				Console.WriteLine ("No");

//			Console.ReadKey(true);
		}
	}
}

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Threading;

namespace Codeforces
{
    class Program : IDisposable
    {
        private static readonly TextReader textReader = new StreamReader(Console.OpenStandardInput());
        private static readonly TextWriter textWriter = new StreamWriter(Console.OpenStandardOutput());

        void Solve()
        {
            var str = Console.ReadLine().Split(' ');
            var a = int.Parse(str[0]);
            var b = int.Parse(str[1]);
            var c = int.Parse(str[2]);

            for (int i = 0; i <= 10000; i++)
            {
                for (int j = 0; j <= 10000; j++)
                {
                    var lclRes = i*a + j*b;
                    if (lclRes == c)
                    {
                        Console.WriteLine("Yes");
                        return;
                    }
                }
            }
            Console.WriteLine("No");
           // Console.ReadLine();
        }

        static void Main(string[] args)
        {
            var p = new Program();
            p.Solve();
            p.Dispose();
        }

        #region Helpers

        private static int ReadInt()
        {
            return int.Parse(textReader.ReadLine());
        }

        private static long ReadLong()
        {
            return long.Parse(textReader.ReadLine());
        }

        private static int[] ReadIntArray()
        {
            return textReader.ReadLine().Split(' ').Select(int.Parse).ToArray();
        }
        #endregion

        public void Dispose()
        {
            textReader.Close();
            textWriter.Close();
        }
    }
}

using System;

namespace CodeForces
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] input = Console.ReadLine().Split();
            double a = double.Parse(input[0]);
            double b = double.Parse(input[1]);
            double c = double.Parse(input[2]);
            double answer = 0;
            string s = "NO";
            bool bb = false;
            for (int i = 0; i <= 10000; i++)
            {
                if (a * i > c)
                    break;
                for(int j = 0; j <= 10000; j++)
                {
                    answer = a * i + b * j;
                    if (answer == c)
                    {
                        s = "YES";
                    }
                    if (answer > c)
                    {
                        bb = true;
                        break;
                    }
                }
            }
            Console.WriteLine(s);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ForCodeForces
{
    class Program
    {
        static void Main(string[] args)
        {
            string s = Console.ReadLine();
            string[] array = s.Split(' ');
            int[] numbers = new int[3];
            for (int i = 0; i < array.Length; i++)
                numbers[i] = int.Parse(array[i]);
            bool flag = false;

            for (int i = 0; i <= (int) (numbers[2]/numbers[0]); i++)
            {
                for (int j = 0; j <= (int) (numbers[2]/numbers[1]); j++)
                {
                    if (numbers[0]*i + numbers[1]*j == numbers[2])
                    {
                        flag = true;
                        break;
                    }
                }
            }
            Console.WriteLine(flag ? "Yes" : "No");
            Console.ReadLine();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Data;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Security;
using System.Text;

namespace Codeforces
{
    class Program
    {
        private static string readString() => Console.ReadLine();
        private static T readValue<T>() => (T)Convert.ChangeType(readString(), typeof(T));
        private static string[] readStrings(char delimiter = ' ') => readString().Split(delimiter);
        private static T[] readValues<T>(char delimiter = ' ') => readStrings(delimiter: delimiter).Select(x => (T)Convert.ChangeType(x, typeof(T))).ToArray();
        private static void write<T>(T s) => Console.WriteLine(s);

        private static int binarySearch<T>(List<T> list, T target) where T : IComparable
        {
            int l = 0, r = list.Count - 1;
            while (l <= r)
            {
                var m = (int)Math.Floor((double)(l + r) / 2);
                if (list[m].CompareTo(target) <= 0)
                    if (m == r || list[m + 1].CompareTo(target) > 0)
                        return m;
                    else
                        l = m + 1;
                else
                    r = m - 1;
            }
            return -1;
        }

        private static int quickSortPartition<T>(List<T> arr, int left, int right, Comparer<T> comparer)
        {
            T pivot = arr[left];
            while (true)
            {
                while (comparer.Compare(arr[left], pivot) < 0)
                    left++;
                while (comparer.Compare(arr[right], pivot) > 0)
                    right--;
                if (left < right)
                {
                    if (comparer.Compare(arr[left], arr[right]) == 0)
                        return right;

                    T temp = arr[left];
                    arr[left] = arr[right];
                    arr[right] = temp;
                }
                else
                    return right;
            }
        }
        private static void quickSort<T>(List<T> arr, int left, int right, Comparer<T> comparer)
        {
            if (left < right)
            {
                int pivot = quickSortPartition(arr, left, right, comparer);
                if (pivot > 1)
                    quickSort(arr, left, pivot - 1, comparer);
                if (pivot + 1 < right)
                    quickSort(arr, pivot + 1, right, comparer);
            }
        }

        private static void watermelon()
        {
            var w = readValue<int>();
            write(w >= 4 && w % 2 == 0 ? "YES" : "NO");
        }
        private static void wayTooLongWords()
        {
            var words = new List<string>();

            var n = readValue<int>();
            for (int i = 0; i < n; ++i)
                words.Add(readString());

            foreach (var word in words)
                write(word.Length <= 10 ? word : $"{word.First()}{word.Length - 2}{word.Last()}");
        }
        private static void team()
        {
            int solve = 0;

            var n = readValue<int>();
            for (int i = 0; i < n; ++i)
                if (readValues<int>().Where(x => x == 1).Count() > 1)
                    ++solve;

            write(solve);
        }
        private static void football()
        {
            var positions = readString();
            for (int i = 6; i < positions.Length; ++i)
                if (positions.Substring(i - 6, 6) == (positions[i] == '0' ? "000000" : "111111"))
                {
                    write("YES");
                    return;
                }
            write("NO");
        }
        private static void theatreSquare()
        {
            var sizes = readValues<int>();
            write((long)Math.Ceiling((double)sizes[0] / (double)sizes[2]) * (long)Math.Ceiling((double)sizes[1] / (double)sizes[2]));
        }
        private static void stringTask()
        {
            var Vowels = new HashSet<char> { 'a', 'o', 'y', 'e', 'u', 'i' };
            var sb = new StringBuilder();
            var s = readString().ToLower();
            foreach (var c in s)
                if (!Vowels.Contains(c))
                {
                    sb.Append('.');
                    sb.Append(c);
                }

            write(sb.ToString());
        }
        private static void taxi()
        {
            int taxis = 0;
            var groups = new Dictionary<int, int> { { 1, 0 }, { 2, 0 }, { 3, 0 } };

            readValue<int>();
            var groupSizes = readValues<int>();
            foreach (var size in groupSizes)
                if (size == 4)
                    ++taxis;
                else
                    groups[size] = groups[size] + 1;

            taxis += groups[3];
            groups[1] = groups[1] - Math.Min(groups[1], groups[3]);

            taxis += groups[2] / 2;
            if (groups[2] % 2 == 1)
            {
                ++taxis;
                groups[1] = groups[1] - 2;
            }

            if (groups[1] > 0)
                taxis += (int)Math.Ceiling((double)groups[1] / 4.0);

            write(taxis);
        }
        private static void fancyFence()
        {
            var a = readValue<int>();
            for (double i = 3.0; ; i += 1.0)
            {
                var x = (double)(i - 2.0) * 180.0 / i;
                if (a <= x)
                {
                    write(a < x ? "NO" : "YES");
                    break;
                }
            }
        }
        private static void interestingDrink()
        {
            readString();
            var prices = readValues<int>().OrderBy(x => x).ToList();
            var days = readValue<int>();
            for (int i = 0; i < days; ++i)
                write(binarySearch(prices, readValue<int>()) + 1);
        }
        private static void compilationErrors()
        {
            readString();
            Dictionary<int, int> errors = readValues<int>().GroupBy(x => x).ToDictionary(x => x.Key, x => x.Count()), errors1 = new Dictionary<int, int>();
            foreach (var error in readValues<int>())
            {
                if (errors[error] > 1)
                    errors[error] = errors[error] - 1;
                else
                    errors.Remove(error);

                if (errors1.TryGetValue(error, out var count))
                    errors1[error] = count + 1;
                else
                    errors1.Add(error, 1);
            }
            write(errors.First().Key);

            foreach (var error in readValues<int>())
                if (errors1[error] > 1)
                    errors1[error] = errors1[error] - 1;
                else
                    errors1.Remove(error);
            write(errors1.First().Key);
        }
        private static void doubleCola()
        {
            var idToName = new Dictionary<int, string> { { 0, "Sheldon" }, { 1, "Leonard" }, { 2, "Penny" }, { 3, "Rajesh" }, { 4, "Howard" } };
            int n = readValue<int>(), i = 1;
            for (; n > i * 5; i *= 2)
                n -= i * 5;
            write(idToName[(n - 1) / i]);
        }
        private static void ilyaAndQueries()
        {
            var dic = new Dictionary<int, int>();
            var list = new List<Tuple<int, int>>();

            var s = readString();
            int start = 0, dicStart = 0;
            for (int j = 0; j < s.Length - 1; ++j)
                if (s[j] != s[j + 1])
                {
                    if (start < j)
                    {
                        list.Add(new Tuple<int, int>(start + 1, j + 1));
                        for (; dicStart < j + 1; ++dicStart)
                            dic.Add(dicStart, list.Count - 1);
                    }
                    start = j + 1;
                }
            if (start < s.Length - 1)
            {
                list.Add(new Tuple<int, int>(start + 1, s.Length));
                for (; dicStart < s.Length; ++dicStart)
                    dic.Add(dicStart, list.Count - 1);
            }

            var m = readValue<int>();
            for (int j = 0; j < m; ++j)
            {
                var q = readValues<int>();
                int l = q[0], r = q[1], result = 0;
                if (dic.TryGetValue(l, out var i))
                    for (; i < list.Count && r >= list[i].Item1; ++i)
                        if (l < list[i].Item2)
                            result += Math.Min(r, list[i].Item2) - Math.Max(l, list[i].Item1);
                write(result);
            }
        }
        private static void twoTeamsComposing()
        {
            var n = readValue<int>();
            var skills = readValues<int>().GroupBy(x => x).ToDictionary(x => x.Key, x => x.Count());
        }
        #region Laptop
        private class Laptop
        {
            internal int Price { get; private set; }
            internal int Quality { get; private set; }
            internal Laptop(int[] values)
            {
                Price = values[0];
                Quality = values[1];
            }
        }
        private class Laptop_Comparer_Price : Comparer<Laptop>
        {
            public override int Compare([AllowNull] Laptop x, [AllowNull] Laptop y) => x.Price - y.Price;
        }
        private class Laptop_Comparer_Quality : Comparer<Laptop>
        {
            public override int Compare([AllowNull] Laptop x, [AllowNull] Laptop y) => x.Quality - y.Quality;
        }
        private static void laptops()
        {
            List<Laptop> prices = new List<Laptop>(), qualities = new List<Laptop>();
            var n = readValue<int>();
            for (int i = 0; i < n; ++i)
            {
                var laptop = new Laptop(readValues<int>());
                prices.Add(laptop);
                qualities.Add(laptop);
            }

            for (int i = 0; i < n; ++i)
                if (prices[i] != qualities[i])
                {
                    write("Happy Alex");
                    return;
                }
            write("Poor Alex");
        }
        #endregion
        private static void fence()
        {
            int k = readValues<int>()[1], minI = 0, currentH = 0;
            int[] h = readValues<int>();

            for (int i = 0; i < k; ++i)
                currentH += h[i];
            var minH = currentH;

            for (int i = 1; i < h.Length - k + 1; ++i)
            {
                currentH = currentH - h[i - 1] + h[i + k - 1];
                if (minH > currentH)
                {
                    minH = currentH;
                    minI = i;
                }
            }

            write(minI + 1);
        }
        #region serejaAndSuffixes
        private class SerejaL
        {
            internal int L { get; private set; }
            internal int Result;
            internal SerejaL(int l)
            {
                L = l;
            }
        }
        private class SerejaLComparerL : Comparer<SerejaL>
        {
            public override int Compare([AllowNull] SerejaL x, [AllowNull] SerejaL y) => x.L - y.L;
        }
        private static void serejaGetLs(int m, out List<SerejaL> listDistinct, out List<SerejaL> listOrdered)
        {
            listDistinct = new List<SerejaL>();
            listOrdered = new List<SerejaL>();
            var dic = new Dictionary<int, SerejaL>();
            for (int i = 0; i < m; ++i)
            {
                var l = readValue<int>() - 1;
                if (!dic.TryGetValue(l, out var item))
                {
                    item = new SerejaL(l);
                    dic.Add(l, item);
                    listDistinct.Add(item);
                }
                listOrdered.Add(item);
            }
            quickSort(listDistinct, 0, listDistinct.Count - 1, new SerejaLComparerL());
        }
        private static void serejaAndSuffixes()
        {
            var m = readValues<int>()[1];
            var a = readValues<int>();
            serejaGetLs(m, out var listDistinct, out var listOrdered);

            var distinct = new HashSet<int>();
            for (int i = listDistinct.Count - 1, j = a.Length - 1; i >= 0; --i)
            {
                for (; j >= listDistinct[i].L; --j)
                    if (!distinct.Contains(a[j]))
                        distinct.Add(a[j]);

                listDistinct[i].Result = distinct.Count;
            }

            foreach (var item in listOrdered)
                write(item.Result);
        }
        #endregion
        private static void bowWowTimetable()
        {
            string s = readString(), r = "1";
            int i = 1;
            for (; r.Length < s.Length; ++i, r = r + "00") ;
            if (r.Length > s.Length || !s.Substring(1).Contains('1'))
                write(i - 1);
            else
                write(i);
        }
        private static void digits()
        {
            readString();
            var numbers = readValues<int>().GroupBy(x => x).ToDictionary(x => x.Key, x => x.Count());
            if (!numbers.ContainsKey(0))
            {
                write(-1);
                return;
            }
        }
        private static void lifeWithoutZeros()
        {
            long a = readValue<int>(), b = readValue<int>(), c = a + b;
            write(Convert.ToInt64(a.ToString().Replace("0", "")) + Convert.ToInt64(b.ToString().Replace("0", "")) == Convert.ToInt64(c.ToString().Replace("0", "")) ? "YES" : "NO");
        }
        private static void permutation()
        {
            var n = readValue<int>();
            var a = readValues<int>();
            write(n - a.Where(x => x <= n).Distinct().Count());
        }
        private static void hamsterFarm()
        {
            var n = readValues<long>()[0];
            var k = readValues<long>();
            int bestI = 0;
            for (int i = 1; i < k.Length; ++i)
                if (n % k[i] < n % k[bestI])
                    bestI = i;
            write($"{bestI + 1} {n / k[bestI]}");
        }
        private static void shellGame()
        {
            int n = readValue<int>(), x = readValue<int>();
            if (x == 1)
            {
                if (n % 2 == 1)
                    x = 0;
                else
                    x = 2;
                --n;
            }
            for (int i = n % 6; i > 0; --i)
                if (i % 2 == 1)
                {
                    if (x == 0)
                        x = 1;
                    else if (x == 1)
                        x = 0;
                }
                else if (x == 1)
                    x = 2;
                else if (x == 2)
                    x = 1;
            write(x);
        }
        private static void ACM_ICPC()
        {
            int[] a = readValues<int>(), score = new int[2], members = new int[2];
            for (int i1 = 0; i1 < 2; ++i1)
            {
                score[i1] = a[0];
                members[i1] = 1;
                for (int i2 = 0; i2 < 2; ++i2)
                {
                    score[i2] += a[1];
                    members[i2] += 1;
                    for (int i3 = 0; i3 < 2; ++i3)
                    {
                        score[i3] += a[2];
                        members[i3] += 1;
                        for (int i4 = 0; i4 < 2; ++i4)
                            if (members[i4] < 3)
                            {
                                score[i4] += a[3];
                                members[i4] += 1;
                                for (int i5 = 0; i5 < 2; ++i5)
                                    if (members[i5] < 3)
                                    {
                                        score[i5] += a[4];
                                        members[i5] += 1;
                                        for (int i6 = 0; i6 < 2; ++i6)
                                            if (members[i6] < 3)
                                            {
                                                score[i6] += a[5];
                                                members[i6] += 1;
                                                if (score[0] == score[1])
                                                {
                                                    write("YES");
                                                    return;
                                                }
                                                score[i6] -= a[5];
                                                members[i6] -= 1;
                                            }
                                        score[i5] -= a[4];
                                        members[i5] -= 1;
                                    }
                                score[i4] -= a[3];
                                members[i4] -= 1;
                            }
                        score[i3] -= a[2];
                        members[i3] -= 1;
                    }
                    score[i2] -= a[1];
                    members[i2] -= 1;
                }
                score[i1] = 0;
                members[i1] = 0;
            }
            write("NO");
        }
        private static void mex()
        {
            var x = readValues<int>()[1];
            var n = readValues<int>();
            write(x - n.Count(y => y < x) + (n.Contains(x) ? 1 : 0));
        }
        private static void minimumProduct()
        {
            var input = readValues<int>();
            int a = input[0], b = input[1], x = input[2], y = input[3], n = input[4], minA = Math.Min(a - x, n), minB = Math.Min(b - y, n);
            if (a - minA <= b - minB)
            {
                a -= minA;
                n -= minA;
            }
            else
            {
                b -= minB;
                n -= minB;
            }

            if (n > 0)
                if (a > x)
                    a -= Math.Min(a - x, n);
                else if (b > y)
                    b -= Math.Min(b - y, n);

            write((long)a * (long)b);
        }
        private static void shovelsAndSwords()
        {
            var input = readValues<int>();
            int a = input[0], b = input[1], result = 0;
            if (a > b)
            {
                var min = Math.Min(a - b, b);
                a -= min * 2;
                b -= min;
                result += min;
            }
            else if (b > a)
            {
                var min = Math.Min(b - a, a);
                a -= min;
                b -= min * 2;
                result += min;
            }
            int d = Math.Min(a / 3, b / 3);
            a -= d * 3;
            b -= d * 3;
            result += d * 2;
            if (a > 0 && b > 0 && (a > 1 || b > 1))
                ++result;
            write(result);
        }
        private static void matrixGame()
        {
            var input = readValues<int>();
            int n = input[0], m = input[1];
            HashSet<int> claimedRows = new HashSet<int>(), claimedColumns = new HashSet<int>();
            for (int i = 0; i < n; ++i)
            {
                input = readValues<int>();
                for (int j = 0; j < m; ++j)
                    if (input[j] == 1)
                    {
                        if (!claimedRows.Contains(i))
                            claimedRows.Add(i);
                        if (!claimedColumns.Contains(j))
                            claimedColumns.Add(j);
                    }
            }
            write(Math.Min(n - claimedRows.Count, m - claimedColumns.Count) % 2 == 0 ? "Vivek" : "Ashish");
        }
        private static void cinemaLine()
        {
            readString();
            var clerk = new Dictionary<int, int> { { 25, 0 }, { 50, 0 } };
            foreach (var a in readValues<int>())
                switch (a)
                {
                    case 25:
                        clerk[25] += 1;
                        break;
                    case 50:
                        if (clerk[25] > 0)
                        {
                            clerk[25] -= 1;
                            clerk[50] += 1;
                        }
                        else
                        {
                            write("NO");
                            return;
                        }
                        break;
                    default: // 100
                        if (clerk[50] > 0 && clerk[25] > 0)
                        {
                            clerk[25] -= 1;
                            clerk[50] -= 1;
                        }
                        else if (clerk[25] > 2)
                            clerk[25] -= 3;
                        else
                        {
                            write("NO");
                            return;
                        }
                        break;
                }
            write("YES");
        }
        private static void kindAnton()
        {
            readString();
            int[] a = readValues<int>(), b = readValues<int>();
            bool positive1 = false, negative1 = false;
            HashSet<int> positive = new HashSet<int>(), negative = new HashSet<int>();
            for (int i = 0; i < a.Length; ++i)
            {
                int diff = b[i] - a[i];
                if (((diff > 0 && !positive1) || (diff < 0 && !negative1)) && !(diff > 0 ? positive : negative).Any(x => diff % x == 0))
                {
                    write("NO");
                    return;
                }
                if (a[i] > 0)
                {
                    if (!positive1)
                        if (a[i] == 1)
                        {
                            positive1 = true;
                            if (negative1)
                            {
                                write("YES");
                                return;
                            }
                        }
                        else if (!positive.Contains(a[i]))
                            positive.Add(a[i]);
                }
                else if (a[i] < 0 && !negative1)
                    if (a[i] == -1)
                    {
                        negative1 = true;
                        if (positive1)
                        {
                            write("YES");
                            return;
                        }
                    }
                    else if (!negative.Contains(a[i]))
                        negative.Add(a[i]);
            }
            write("YES");
        }
        private static void staircases()
        {
            var input = readValues<int>();
            int n = input[0], mn = input[1];
            if (mn == 0)
            {
                write("YES");
                return;
            }
            var m = readValues<int>().OrderBy(x => x).ToList();
            if (m[0] == 1 || m[m.Count - 1] == n)
            {
                write("NO");
                return;
            }
            for (int i = 0; i < m.Count - 2; ++i)
                if (m[i] == m[i + 1] - 1 && m[i] == m[i + 2] - 2)
                {
                    write("NO");
                    return;
                }
            write("YES");
        }
        private static void blownGarland()
        {
            var colors = new Dictionary<char, int> { { 'R', 0 }, { 'Y', 0 }, { 'B', 0 }, { 'G', 0 } };
            var s = readString();

            var colorPerPosition = new char[4];
            foreach (var color in colors)
                colorPerPosition[s.IndexOf(color.Key) % 4] = color.Key;

            for (int i = 0; i < s.Length; ++i)
                if (s[i] == '!')
                    colors[colorPerPosition[i % 4]] += 1;

            write($"{colors['R']} {colors['B']} {colors['Y']} {colors['G']}");
        }
        private static void mikeAndFax()
        {
            var s = readString();
            int k = readValue<int>();

            if (s.Length % k != 0)
            {
                write("NO");
                return;
            }

            int size = s.Length / k;
            for (int i = 0; i < s.Length; i += size)
                for (int j1 = i + size / 2 - 1, j2 = i + size / 2 + size % 2; j1 >= i; --j1, ++j2)
                    if (s[j1] != s[j2])
                    {
                        write("NO");
                        return;
                    }

            write("YES");
        }
        #region weirdRounding
        private static bool weirdRounding_Recursion(string ns, int kp, int d)
        {
            if (d > 0)
                for (int i = ns[1] == '0' && ns.Length > 2 ? 1 : 0; i < ns.Length; ++i)
                {
                    string nsNew = ns.Remove(i, 1);
                    int n = Convert.ToInt32(nsNew);
                    if (n % kp == 0 || weirdRounding_Recursion(nsNew, kp, d - 1))
                        return true;
                }
            return false;
        }
        private static void weirdRounding()
        {
            var input = readStrings();
            string ns = input[0];
            int n = Convert.ToInt32(ns), k = Convert.ToInt32(input[1]), kp = (int)Math.Pow(10, k);

            if (n < kp)
                write(ns.Length - 1);
            else if (n % kp == 0)
                write(0);
            else
                for (int d = 1; d < ns.Length; ++d)
                    if (weirdRounding_Recursion(ns, kp, d))
                    {
                        write(d);
                        return;
                    }
        }
        #endregion
        private static void wilburArray()
        {
            readString();
            int[] b = readValues<int>();
            long result = Math.Abs(b[0]);
            for (int i = 1; i < b.Length; ++i)
                result += Math.Abs(b[i] - b[i - 1]);
            write(result);
        }
        private static void zuhairStrings()
        {
            int k = readValues<int>()[1];
            var s = readString();
            var result = new Dictionary<char, int>();

            for (int i = 0; i < s.Length - k + 1;)
            {
                int j = i + 1;
                for (; j < i + k && s[i] == s[j]; ++j) ;
                if (j == i + k)
                    if (!result.ContainsKey(s[i]))
                        result.Add(s[i], 1);
                    else
                        result[s[i]] += 1;
                i = j;
            }

            write(result.Count > 0 ? result.Max(x => x.Value) : 0);
        }
        private static void artfulExpedient()
        {
            var n = readValue<int>();
            int[] x = readValues<int>(), y = readValues<int>();
            var numbers = x.Union(y).ToHashSet();
            var resultEven = true;

            for (int i = 0; i < n; ++i)
                for (int j = 0; j < n; ++j)
                    if (numbers.Contains(x[i] ^ y[j]))
                        resultEven = !resultEven;

            write(resultEven ? "Karen" : "Koyomi");
        }
        private static void ebonyIvory()
        {
            var input = readValues<int>();
            int a = input[0], b = input[1], c = input[2];
            for (int i = 0; i <= c; i += a)
                if ((c - i) % b == 0)
                {
                    write("Yes");
                    return;
                }
            write("No");
        }

        static void Main(string[] args)
        {
            //var t = readValue<int>();
            //for (int i = 0; i < t; ++i)
            ebonyIvory();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Data;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Security;
using System.Text;

namespace Codeforces
{
    class Program
    {
        private static string readString() => Console.ReadLine();
        private static T readValue<T>() => (T)Convert.ChangeType(readString(), typeof(T));
        private static string[] readStrings(char delimiter = ' ') => readString().Split(delimiter);
        private static T[] readValues<T>(char delimiter = ' ') => readStrings(delimiter: delimiter).Select(x => (T)Convert.ChangeType(x, typeof(T))).ToArray();
        private static void write<T>(T s) => Console.WriteLine(s);

        private static int binarySearch<T>(List<T> list, T target) where T : IComparable
        {
            int l = 0, r = list.Count - 1;
            while (l <= r)
            {
                var m = (int)Math.Floor((double)(l + r) / 2);
                if (list[m].CompareTo(target) <= 0)
                    if (m == r || list[m + 1].CompareTo(target) > 0)
                        return m;
                    else
                        l = m + 1;
                else
                    r = m - 1;
            }
            return -1;
        }

        private static int quickSortPartition<T>(List<T> arr, int left, int right, Comparer<T> comparer)
        {
            T pivot = arr[left];
            while (true)
            {
                while (comparer.Compare(arr[left], pivot) < 0)
                    left++;
                while (comparer.Compare(arr[right], pivot) > 0)
                    right--;
                if (left < right)
                {
                    if (comparer.Compare(arr[left], arr[right]) == 0)
                        return right;

                    T temp = arr[left];
                    arr[left] = arr[right];
                    arr[right] = temp;
                }
                else
                    return right;
            }
        }
        private static void quickSort<T>(List<T> arr, int left, int right, Comparer<T> comparer)
        {
            if (left < right)
            {
                int pivot = quickSortPartition(arr, left, right, comparer);
                if (pivot > 1)
                    quickSort(arr, left, pivot - 1, comparer);
                if (pivot + 1 < right)
                    quickSort(arr, pivot + 1, right, comparer);
            }
        }

        private static void watermelon()
        {
            var w = readValue<int>();
            write(w >= 4 && w % 2 == 0 ? "YES" : "NO");
        }
        private static void wayTooLongWords()
        {
            var words = new List<string>();

            var n = readValue<int>();
            for (int i = 0; i < n; ++i)
                words.Add(readString());

            foreach (var word in words)
                write(word.Length <= 10 ? word : $"{word.First()}{word.Length - 2}{word.Last()}");
        }
        private static void team()
        {
            int solve = 0;

            var n = readValue<int>();
            for (int i = 0; i < n; ++i)
                if (readValues<int>().Where(x => x == 1).Count() > 1)
                    ++solve;

            write(solve);
        }
        private static void football()
        {
            var positions = readString();
            for (int i = 6; i < positions.Length; ++i)
                if (positions.Substring(i - 6, 6) == (positions[i] == '0' ? "000000" : "111111"))
                {
                    write("YES");
                    return;
                }
            write("NO");
        }
        private static void theatreSquare()
        {
            var sizes = readValues<int>();
            write((long)Math.Ceiling((double)sizes[0] / (double)sizes[2]) * (long)Math.Ceiling((double)sizes[1] / (double)sizes[2]));
        }
        private static void stringTask()
        {
            var Vowels = new HashSet<char> { 'a', 'o', 'y', 'e', 'u', 'i' };
            var sb = new StringBuilder();
            var s = readString().ToLower();
            foreach (var c in s)
                if (!Vowels.Contains(c))
                {
                    sb.Append('.');
                    sb.Append(c);
                }

            write(sb.ToString());
        }
        private static void taxi()
        {
            int taxis = 0;
            var groups = new Dictionary<int, int> { { 1, 0 }, { 2, 0 }, { 3, 0 } };

            readValue<int>();
            var groupSizes = readValues<int>();
            foreach (var size in groupSizes)
                if (size == 4)
                    ++taxis;
                else
                    groups[size] = groups[size] + 1;

            taxis += groups[3];
            groups[1] = groups[1] - Math.Min(groups[1], groups[3]);

            taxis += groups[2] / 2;
            if (groups[2] % 2 == 1)
            {
                ++taxis;
                groups[1] = groups[1] - 2;
            }

            if (groups[1] > 0)
                taxis += (int)Math.Ceiling((double)groups[1] / 4.0);

            write(taxis);
        }
        private static void fancyFence()
        {
            var a = readValue<int>();
            for (double i = 3.0; ; i += 1.0)
            {
                var x = (double)(i - 2.0) * 180.0 / i;
                if (a <= x)
                {
                    write(a < x ? "NO" : "YES");
                    break;
                }
            }
        }
        private static void interestingDrink()
        {
            readString();
            var prices = readValues<int>().OrderBy(x => x).ToList();
            var days = readValue<int>();
            for (int i = 0; i < days; ++i)
                write(binarySearch(prices, readValue<int>()) + 1);
        }
        private static void compilationErrors()
        {
            readString();
            Dictionary<int, int> errors = readValues<int>().GroupBy(x => x).ToDictionary(x => x.Key, x => x.Count()), errors1 = new Dictionary<int, int>();
            foreach (var error in readValues<int>())
            {
                if (errors[error] > 1)
                    errors[error] = errors[error] - 1;
                else
                    errors.Remove(error);

                if (errors1.TryGetValue(error, out var count))
                    errors1[error] = count + 1;
                else
                    errors1.Add(error, 1);
            }
            write(errors.First().Key);

            foreach (var error in readValues<int>())
                if (errors1[error] > 1)
                    errors1[error] = errors1[error] - 1;
                else
                    errors1.Remove(error);
            write(errors1.First().Key);
        }
        private static void doubleCola()
        {
            var idToName = new Dictionary<int, string> { { 0, "Sheldon" }, { 1, "Leonard" }, { 2, "Penny" }, { 3, "Rajesh" }, { 4, "Howard" } };
            int n = readValue<int>(), i = 1;
            for (; n > i * 5; i *= 2)
                n -= i * 5;
            write(idToName[(n - 1) / i]);
        }
        private static void ilyaAndQueries()
        {
            var dic = new Dictionary<int, int>();
            var list = new List<Tuple<int, int>>();

            var s = readString();
            int start = 0, dicStart = 0;
            for (int j = 0; j < s.Length - 1; ++j)
                if (s[j] != s[j + 1])
                {
                    if (start < j)
                    {
                        list.Add(new Tuple<int, int>(start + 1, j + 1));
                        for (; dicStart < j + 1; ++dicStart)
                            dic.Add(dicStart, list.Count - 1);
                    }
                    start = j + 1;
                }
            if (start < s.Length - 1)
            {
                list.Add(new Tuple<int, int>(start + 1, s.Length));
                for (; dicStart < s.Length; ++dicStart)
                    dic.Add(dicStart, list.Count - 1);
            }

            var m = readValue<int>();
            for (int j = 0; j < m; ++j)
            {
                var q = readValues<int>();
                int l = q[0], r = q[1], result = 0;
                if (dic.TryGetValue(l, out var i))
                    for (; i < list.Count && r >= list[i].Item1; ++i)
                        if (l < list[i].Item2)
                            result += Math.Min(r, list[i].Item2) - Math.Max(l, list[i].Item1);
                write(result);
            }
        }
        private static void twoTeamsComposing()
        {
            var n = readValue<int>();
            var skills = readValues<int>().GroupBy(x => x).ToDictionary(x => x.Key, x => x.Count());
        }
        #region Laptop
        private class Laptop
        {
            internal int Price { get; private set; }
            internal int Quality { get; private set; }
            internal Laptop(int[] values)
            {
                Price = values[0];
                Quality = values[1];
            }
        }
        private class Laptop_Comparer_Price : Comparer<Laptop>
        {
            public override int Compare([AllowNull] Laptop x, [AllowNull] Laptop y) => x.Price - y.Price;
        }
        private class Laptop_Comparer_Quality : Comparer<Laptop>
        {
            public override int Compare([AllowNull] Laptop x, [AllowNull] Laptop y) => x.Quality - y.Quality;
        }
        private static void laptops()
        {
            List<Laptop> prices = new List<Laptop>(), qualities = new List<Laptop>();
            var n = readValue<int>();
            for (int i = 0; i < n; ++i)
            {
                var laptop = new Laptop(readValues<int>());
                prices.Add(laptop);
                qualities.Add(laptop);
            }

            for (int i = 0; i < n; ++i)
                if (prices[i] != qualities[i])
                {
                    write("Happy Alex");
                    return;
                }
            write("Poor Alex");
        }
        #endregion
        private static void fence()
        {
            int k = readValues<int>()[1], minI = 0, currentH = 0;
            int[] h = readValues<int>();

            for (int i = 0; i < k; ++i)
                currentH += h[i];
            var minH = currentH;

            for (int i = 1; i < h.Length - k + 1; ++i)
            {
                currentH = currentH - h[i - 1] + h[i + k - 1];
                if (minH > currentH)
                {
                    minH = currentH;
                    minI = i;
                }
            }

            write(minI + 1);
        }
        #region serejaAndSuffixes
        private class SerejaL
        {
            internal int L { get; private set; }
            internal int Result;
            internal SerejaL(int l)
            {
                L = l;
            }
        }
        private class SerejaLComparerL : Comparer<SerejaL>
        {
            public override int Compare([AllowNull] SerejaL x, [AllowNull] SerejaL y) => x.L - y.L;
        }
        private static void serejaGetLs(int m, out List<SerejaL> listDistinct, out List<SerejaL> listOrdered)
        {
            listDistinct = new List<SerejaL>();
            listOrdered = new List<SerejaL>();
            var dic = new Dictionary<int, SerejaL>();
            for (int i = 0; i < m; ++i)
            {
                var l = readValue<int>() - 1;
                if (!dic.TryGetValue(l, out var item))
                {
                    item = new SerejaL(l);
                    dic.Add(l, item);
                    listDistinct.Add(item);
                }
                listOrdered.Add(item);
            }
            quickSort(listDistinct, 0, listDistinct.Count - 1, new SerejaLComparerL());
        }
        private static void serejaAndSuffixes()
        {
            var m = readValues<int>()[1];
            var a = readValues<int>();
            serejaGetLs(m, out var listDistinct, out var listOrdered);

            var distinct = new HashSet<int>();
            for (int i = listDistinct.Count - 1, j = a.Length - 1; i >= 0; --i)
            {
                for (; j >= listDistinct[i].L; --j)
                    if (!distinct.Contains(a[j]))
                        distinct.Add(a[j]);

                listDistinct[i].Result = distinct.Count;
            }

            foreach (var item in listOrdered)
                write(item.Result);
        }
        #endregion
        private static void bowWowTimetable()
        {
            string s = readString(), r = "1";
            int i = 1;
            for (; r.Length < s.Length; ++i, r = r + "00") ;
            if (r.Length > s.Length || !s.Substring(1).Contains('1'))
                write(i - 1);
            else
                write(i);
        }
        private static void digits()
        {
            readString();
            var numbers = readValues<int>().GroupBy(x => x).ToDictionary(x => x.Key, x => x.Count());
            if (!numbers.ContainsKey(0))
            {
                write(-1);
                return;
            }
        }
        private static void lifeWithoutZeros()
        {
            long a = readValue<int>(), b = readValue<int>(), c = a + b;
            write(Convert.ToInt64(a.ToString().Replace("0", "")) + Convert.ToInt64(b.ToString().Replace("0", "")) == Convert.ToInt64(c.ToString().Replace("0", "")) ? "YES" : "NO");
        }
        private static void permutation()
        {
            var n = readValue<int>();
            var a = readValues<int>();
            write(n - a.Where(x => x <= n).Distinct().Count());
        }
        private static void hamsterFarm()
        {
            var n = readValues<long>()[0];
            var k = readValues<long>();
            int bestI = 0;
            for (int i = 1; i < k.Length; ++i)
                if (n % k[i] < n % k[bestI])
                    bestI = i;
            write($"{bestI + 1} {n / k[bestI]}");
        }
        private static void shellGame()
        {
            int n = readValue<int>(), x = readValue<int>();
            if (x == 1)
            {
                if (n % 2 == 1)
                    x = 0;
                else
                    x = 2;
                --n;
            }
            for (int i = n % 6; i > 0; --i)
                if (i % 2 == 1)
                {
                    if (x == 0)
                        x = 1;
                    else if (x == 1)
                        x = 0;
                }
                else if (x == 1)
                    x = 2;
                else if (x == 2)
                    x = 1;
            write(x);
        }
        private static void ACM_ICPC()
        {
            int[] a = readValues<int>(), score = new int[2], members = new int[2];
            for (int i1 = 0; i1 < 2; ++i1)
            {
                score[i1] = a[0];
                members[i1] = 1;
                for (int i2 = 0; i2 < 2; ++i2)
                {
                    score[i2] += a[1];
                    members[i2] += 1;
                    for (int i3 = 0; i3 < 2; ++i3)
                    {
                        score[i3] += a[2];
                        members[i3] += 1;
                        for (int i4 = 0; i4 < 2; ++i4)
                            if (members[i4] < 3)
                            {
                                score[i4] += a[3];
                                members[i4] += 1;
                                for (int i5 = 0; i5 < 2; ++i5)
                                    if (members[i5] < 3)
                                    {
                                        score[i5] += a[4];
                                        members[i5] += 1;
                                        for (int i6 = 0; i6 < 2; ++i6)
                                            if (members[i6] < 3)
                                            {
                                                score[i6] += a[5];
                                                members[i6] += 1;
                                                if (score[0] == score[1])
                                                {
                                                    write("YES");
                                                    return;
                                                }
                                                score[i6] -= a[5];
                                                members[i6] -= 1;
                                            }
                                        score[i5] -= a[4];
                                        members[i5] -= 1;
                                    }
                                score[i4] -= a[3];
                                members[i4] -= 1;
                            }
                        score[i3] -= a[2];
                        members[i3] -= 1;
                    }
                    score[i2] -= a[1];
                    members[i2] -= 1;
                }
                score[i1] = 0;
                members[i1] = 0;
            }
            write("NO");
        }
        private static void mex()
        {
            var x = readValues<int>()[1];
            var n = readValues<int>();
            write(x - n.Count(y => y < x) + (n.Contains(x) ? 1 : 0));
        }
        private static void minimumProduct()
        {
            var input = readValues<int>();
            int a = input[0], b = input[1], x = input[2], y = input[3], n = input[4], minA = Math.Min(a - x, n), minB = Math.Min(b - y, n);
            if (a - minA <= b - minB)
            {
                a -= minA;
                n -= minA;
            }
            else
            {
                b -= minB;
                n -= minB;
            }

            if (n > 0)
                if (a > x)
                    a -= Math.Min(a - x, n);
                else if (b > y)
                    b -= Math.Min(b - y, n);

            write((long)a * (long)b);
        }
        private static void shovelsAndSwords()
        {
            var input = readValues<int>();
            int a = input[0], b = input[1], result = 0;
            if (a > b)
            {
                var min = Math.Min(a - b, b);
                a -= min * 2;
                b -= min;
                result += min;
            }
            else if (b > a)
            {
                var min = Math.Min(b - a, a);
                a -= min;
                b -= min * 2;
                result += min;
            }
            int d = Math.Min(a / 3, b / 3);
            a -= d * 3;
            b -= d * 3;
            result += d * 2;
            if (a > 0 && b > 0 && (a > 1 || b > 1))
                ++result;
            write(result);
        }
        private static void matrixGame()
        {
            var input = readValues<int>();
            int n = input[0], m = input[1];
            HashSet<int> claimedRows = new HashSet<int>(), claimedColumns = new HashSet<int>();
            for (int i = 0; i < n; ++i)
            {
                input = readValues<int>();
                for (int j = 0; j < m; ++j)
                    if (input[j] == 1)
                    {
                        if (!claimedRows.Contains(i))
                            claimedRows.Add(i);
                        if (!claimedColumns.Contains(j))
                            claimedColumns.Add(j);
                    }
            }
            write(Math.Min(n - claimedRows.Count, m - claimedColumns.Count) % 2 == 0 ? "Vivek" : "Ashish");
        }
        private static void cinemaLine()
        {
            readString();
            var clerk = new Dictionary<int, int> { { 25, 0 }, { 50, 0 } };
            foreach (var a in readValues<int>())
                switch (a)
                {
                    case 25:
                        clerk[25] += 1;
                        break;
                    case 50:
                        if (clerk[25] > 0)
                        {
                            clerk[25] -= 1;
                            clerk[50] += 1;
                        }
                        else
                        {
                            write("NO");
                            return;
                        }
                        break;
                    default: // 100
                        if (clerk[50] > 0 && clerk[25] > 0)
                        {
                            clerk[25] -= 1;
                            clerk[50] -= 1;
                        }
                        else if (clerk[25] > 2)
                            clerk[25] -= 3;
                        else
                        {
                            write("NO");
                            return;
                        }
                        break;
                }
            write("YES");
        }
        private static void kindAnton()
        {
            readString();
            int[] a = readValues<int>(), b = readValues<int>();
            bool positive1 = false, negative1 = false;
            HashSet<int> positive = new HashSet<int>(), negative = new HashSet<int>();
            for (int i = 0; i < a.Length; ++i)
            {
                int diff = b[i] - a[i];
                if (((diff > 0 && !positive1) || (diff < 0 && !negative1)) && !(diff > 0 ? positive : negative).Any(x => diff % x == 0))
                {
                    write("NO");
                    return;
                }
                if (a[i] > 0)
                {
                    if (!positive1)
                        if (a[i] == 1)
                        {
                            positive1 = true;
                            if (negative1)
                            {
                                write("YES");
                                return;
                            }
                        }
                        else if (!positive.Contains(a[i]))
                            positive.Add(a[i]);
                }
                else if (a[i] < 0 && !negative1)
                    if (a[i] == -1)
                    {
                        negative1 = true;
                        if (positive1)
                        {
                            write("YES");
                            return;
                        }
                    }
                    else if (!negative.Contains(a[i]))
                        negative.Add(a[i]);
            }
            write("YES");
        }
        private static void staircases()
        {
            var input = readValues<int>();
            int n = input[0], mn = input[1];
            if (mn == 0)
            {
                write("YES");
                return;
            }
            var m = readValues<int>().OrderBy(x => x).ToList();
            if (m[0] == 1 || m[m.Count - 1] == n)
            {
                write("NO");
                return;
            }
            for (int i = 0; i < m.Count - 2; ++i)
                if (m[i] == m[i + 1] - 1 && m[i] == m[i + 2] - 2)
                {
                    write("NO");
                    return;
                }
            write("YES");
        }
        private static void blownGarland()
        {
            var colors = new Dictionary<char, int> { { 'R', 0 }, { 'Y', 0 }, { 'B', 0 }, { 'G', 0 } };
            var s = readString();

            var colorPerPosition = new char[4];
            foreach (var color in colors)
                colorPerPosition[s.IndexOf(color.Key) % 4] = color.Key;

            for (int i = 0; i < s.Length; ++i)
                if (s[i] == '!')
                    colors[colorPerPosition[i % 4]] += 1;

            write($"{colors['R']} {colors['B']} {colors['Y']} {colors['G']}");
        }
        private static void mikeAndFax()
        {
            var s = readString();
            int k = readValue<int>();

            if (s.Length % k != 0)
            {
                write("NO");
                return;
            }

            int size = s.Length / k;
            for (int i = 0; i < s.Length; i += size)
                for (int j1 = i + size / 2 - 1, j2 = i + size / 2 + size % 2; j1 >= i; --j1, ++j2)
                    if (s[j1] != s[j2])
                    {
                        write("NO");
                        return;
                    }

            write("YES");
        }
        #region weirdRounding
        private static bool weirdRounding_Recursion(string ns, int kp, int d)
        {
            if (d > 0)
                for (int i = ns[1] == '0' && ns.Length > 2 ? 1 : 0; i < ns.Length; ++i)
                {
                    string nsNew = ns.Remove(i, 1);
                    int n = Convert.ToInt32(nsNew);
                    if (n % kp == 0 || weirdRounding_Recursion(nsNew, kp, d - 1))
                        return true;
                }
            return false;
        }
        private static void weirdRounding()
        {
            var input = readStrings();
            string ns = input[0];
            int n = Convert.ToInt32(ns), k = Convert.ToInt32(input[1]), kp = (int)Math.Pow(10, k);

            if (n < kp)
                write(ns.Length - 1);
            else if (n % kp == 0)
                write(0);
            else
                for (int d = 1; d < ns.Length; ++d)
                    if (weirdRounding_Recursion(ns, kp, d))
                    {
                        write(d);
                        return;
                    }
        }
        #endregion
        private static void wilburArray()
        {
            readString();
            int[] b = readValues<int>();
            long result = Math.Abs(b[0]);
            for (int i = 1; i < b.Length; ++i)
                result += Math.Abs(b[i] - b[i - 1]);
            write(result);
        }
        private static void zuhairStrings()
        {
            int k = readValues<int>()[1];
            var s = readString();
            var result = new Dictionary<char, int>();

            for (int i = 0; i < s.Length - k + 1;)
            {
                int j = i + 1;
                for (; j < i + k && s[i] == s[j]; ++j) ;
                if (j == i + k)
                    if (!result.ContainsKey(s[i]))
                        result.Add(s[i], 1);
                    else
                        result[s[i]] += 1;
                i = j;
            }

            write(result.Count > 0 ? result.Max(x => x.Value) : 0);
        }
        private static void artfulExpedient()
        {
            var n = readValue<int>();
            int[] x = readValues<int>(), y = readValues<int>();
            var numbers = x.Union(y).ToHashSet();
            var resultEven = true;

            for (int i = 0; i < n; ++i)
                for (int j = 0; j < n; ++j)
                    if (numbers.Contains(x[i] ^ y[j]))
                        resultEven = !resultEven;

            write(resultEven ? "Karen" : "Koyomi");
        }
        private static void ebonyIvory()
        {
            var input = readValues<int>();
            int a = input[0], b = input[1], c = input[2];
            if (a < b)
            {
                var t = a;
                a = b;
                b = t;
            }
            for (; c >= 0; c -= a)
                if (c % b == 0)
                {
                    write("Yes");
                    return;
                }
            write("No");
        }

        static void Main(string[] args)
        {
            //var t = readValue<int>();
            //for (int i = 0; i < t; ++i)
            ebonyIvory();
        }
    }
}

using System;
using System.Linq;

namespace CodeForces
{
	class MainClass
	{
		public static void Main(string[] args)
		{
			string line1 = Console.ReadLine();
			string[] split = line1.Split(new Char[] { ' ', ',', '.', ':', '\t' });
			int a = Int32.Parse(split[0]);
			int b = Int32.Parse(split[1]);
			int c = Int32.Parse(split[2]);
			int gun1 = c;
			bool solved = false;
			while (gun1 > 0)
			{
				gun1 -= a;
				if (gun1 % b == 0 && gun1 >= 0)
				{
					solved = true;
				}
			}
			int gun2 = c;
			while (gun2 > 0)
			{
				gun2 -= b;
				if (gun2 % a == 0 && gun2 >= 0)
				{
					solved = true;
				}
			}
			if (solved)
			{
				Console.WriteLine("Yes");
			}
			else
			{
				Console.WriteLine("No");
			}

		}

	}

}

using System;

class Program
{
    static void Main()
    {
        string input = Console.ReadLine();
        string[] args = input.Split();

        //Console.WriteLine($"Num args = {args.Length}");

        var a = int.Parse(args[0]);
        var b = int.Parse(args[1]);
        var c = int.Parse(args[2]);

        //Console.WriteLine($"a = {a}");
        //Console.WriteLine($"b = {b}");
        //Console.WriteLine($"c = {c}");

        int asum = 0;
        bool foundCombination = false;

        while (asum <= c)
        {
            if ((c - asum) % b == 0)
            {
                foundCombination = true;
                break;
            }

            asum += a;
        }

        Console.WriteLine(foundCombination ? "Yes" : "No");
    }
}

using System;

namespace CSharp
{
    public class _633A
    {
        public static void Main()
        {
            string[] tokens = Console.ReadLine().Split();

            int a = int.Parse(tokens[0]);
            int b = int.Parse(tokens[1]);
            int c = int.Parse(tokens[2]);

            bool[] possible = new bool[c + 1];
            possible[0] = true;

            for (int i = 1; i <= c; i++)
            {
                possible[i] = (i >= a && possible[i - a]) || (i >= b && possible[i - b]);
            }

            Console.WriteLine(possible[c] ? "Yes" : "No");
        }
    }
}

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;

namespace Contest
{
    class Program
    {
        static void SetInput()
        {
            var textReader = new StreamReader("input.txt");
            Console.SetIn(textReader);
        }

        static IEnumerable<T> Parse<T>(string line, Func<string, T> converter)
        {
            return line.Split(' ').Select(converter);
        }

        static IEnumerable<int> ReadInts()
        {
            return ReadLine(x => int.Parse(x));
        }

        static IEnumerable<long> ReadLongs()
        {
            return ReadLine(x => long.Parse(x));
        }

        static IEnumerable<double> ReadDoubles()
        {
            return ReadLine(x => double.Parse(x));
        }

        static IEnumerable<T> ReadLine<T>(Func<string, T> converter)
        {
            var line = Console.ReadLine();

            return Parse(line, converter);
        }

        static void Print<T>(IEnumerable<T> values)
        {
            Console.WriteLine(string.Join(" ", values));
        }

        static int[] Copy(int[] array)
        {
            if (array == null) return null;

            var newArray = new int[array.Length];
            Array.Copy(array, newArray, array.Length);
            return newArray;
        }

        static void Main(string[] args)
        {
            //SetInput();

            var input = ReadInts().ToArray();
            var a = input[0];
            var b = input[1];

            var c = input[2];

            var dp = new bool[c + 1];

            dp[0] = true;

            for (int i = Math.Min(a, b); i <= c; i++)
            {
                if (i - a >= 0 && dp[i - a]) dp[i] = true;
                if (i - b >= 0 && dp[i - b]) dp[i] = true;
            }

            Console.WriteLine(dp[c] ? "Yes" : "No");
        }
    }
}

using System;

namespace Olymp
{
  public class ProblemSolver
  {
    public void Solve()
    {
      string[] input = Console.ReadLine().Split();
      int a = int.Parse(input[0]);
      int b = int.Parse(input[1]);
      int c = int.Parse(input[2]);
      int n = c / a;
      for (int i = 0; i <= n; i++)
      {
        int x = c - i * a;
        int j = x / b;
        if(a * i + b * j == c)
        {
          Console.Write("Yes");
          return;
        }
      }
      Console.Write("No");
    }
  }

  class Program
  {
    public static void Main(string[] args)
    {
      var solver = new ProblemSolver();
      solver.Solve();
    }
  }
}

using System;

namespace EbonyAndIvory {

    class Program {

        static void Main(string[] args) {

            string[] s = Console.ReadLine().Split(' ');
            int a = int.Parse(s[0]);
            int b = int.Parse(s[1]);
            int c = int.Parse(s[2]);

            for(int ax = 0; ax * a <= c; ax++) {
                for(int bx = 0; bx * b <= c; bx++) {
                    if(c == (ax * a) + (bx * b)) { Console.WriteLine("Yes"); return; }
                }
            }
            Console.WriteLine("No");
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace TaskA
{
    class Program
    {
        static void Main(string[] args)
        {
            //var s = Console.ReadLine();
            var arr = Console.ReadLine().Split(' ').Select(x => Convert.ToInt32(x)).ToArray();

            var a = arr[0]; //Console.Read();
            var b = arr[1]; // Console.Read();
            var c = arr[2]; // Console.Read();

            int aSteps = c / a + 1;
            int bSteps = c / b + 1;

            for(int i = 0; i <= aSteps; i++)
                for (int j = 0; j <= bSteps; j++)
                {
                    if (a * i + b * j == c)
                    {
                        Console.Write("Yes");
                        return;
                    }
                }

            Console.WriteLine("No");
        }
    }
}

using System;

namespace _A
{
	class MainClass
	{
		public static void Main (string[] args)
		{

			int[] Data = new int[3];

			string[] Temp;
			Temp = (Console.ReadLine ()).Split (' ');
			for (int i = 0; i < 3; i++){

				int x;
				int.TryParse(Temp[i], out x);
				Data[i] = x;

			}

			int T1 = Data[2];
			while (T1 > 0 && Data[2] > 0) {

				T1 = Data [2];
				T1 = T1 % Data [1];
				if (T1 > 0)
					Data[2] -= Data [0];

			}

			if (T1 == 0 || Data[2] == 0)
				Console.WriteLine ("Yes");
			else
				Console.WriteLine ("No");

			Console.ReadLine ();
		}
	}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CF
{
    class Program
    {
        static void Main(string[] args)
        {
            string temp;
            string [] data;
            int[] digitData = new int [3];
            int a, b, c, val = 1;
            bool ready = false;

            temp = Console.ReadLine();
            data = temp.Split(' ');
            for(int i = 0; i < 3; i++)
                digitData[i] = int.Parse(data[i]);

            a = digitData[0];
            b = digitData[1];
            c = digitData[2];

            for (int i = 0; i <= c / a; i++)
            {
                for (int j = 0; j <= c / b; j++)
                {
                    val = i * a + j * b;
                    if (val == c)
                    {
                        ready = true;
                        break;
                    }
                }
                if (ready)
                    break;
            }

            if (!ready)
                Console.WriteLine("No");
            else
                Console.WriteLine("Yes");
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CodeForces
{
	public class Program
	{
		int max = 0;
		public static void Main(string[] args)
		{
			string num = Console.ReadLine();
			string[] numArray = num.Split(null);

			int a = int.Parse(numArray[0]);
			int b = int.Parse(numArray[1]);
			int c = int.Parse(numArray[2]);

			if (c % a == 0 || c % b == 0)
			{
				Console.Write("Yes");
				return;
			}

			int i = 0;
			while (i <= c)
			{
				if ((i == c) || (c-i)%b ==0)
				{
					Console.Write("Yes");
					return;
				}
				i = i + a;
			}

			Console.Write("No");
		}

	}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {

            string[]y=Console.ReadLine().Split(' ');
            int a=int.Parse(y[0]);
            int b=int.Parse(y[1]);
            int n=int.Parse(y[2]);
            bool f=false;
            for(int i=0;i<5001;i++)
            {
                 for(int j=0;j<5001;j++)
                 if(a*i+b*j==n)
                 {
                      f=true;
                      break;

                 }
            }
            if(f)
            Console.WriteLine("YES");
            else
            Console.WriteLine("NO");
        }

    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace LightDark
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] s = Console.ReadLine().Split();
            int a = int.Parse(s[0]);
            int b = int.Parse(s[1]);
            int c = int.Parse(s[2]);
            int lim=c/a;
            bool ok = false;
            for (int i=0;i<=lim;i++)
            {
                int m = (c - i * a) / b;
                if (i*a+m*b==c)
                {
                    ok = true;
                    break;
                }
            }
            if (ok) Console.Write("Yes"); else Console.Write("No");
        }
    }
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;

class TEST{
	static void Main(){
		Sol mySol =new Sol();
		mySol.Solve();
	}
}

class Sol{
	public void Solve(){

		for(;C>=0;C-=A){
			if(C%B==0){
				Console.WriteLine("Yes");
				return;
			}
		}
		Console.WriteLine("No");

	}
	int A,B,C;
	public Sol(){
		var d=ria();
		A=d[0];B=d[1];C=d[2];
	}

	static String rs(){return Console.ReadLine();}
	static int ri(){return int.Parse(Console.ReadLine());}
	static long rl(){return long.Parse(Console.ReadLine());}
	static double rd(){return double.Parse(Console.ReadLine());}
	static String[] rsa(char sep=' '){return Console.ReadLine().Split(sep);}
	static int[] ria(char sep=' '){return Array.ConvertAll(Console.ReadLine().Split(sep),e=>int.Parse(e));}
	static long[] rla(char sep=' '){return Array.ConvertAll(Console.ReadLine().Split(sep),e=>long.Parse(e));}
	static double[] rda(char sep=' '){return Array.ConvertAll(Console.ReadLine().Split(sep),e=>double.Parse(e));}
}

using System;
using System.IO;
using System.Text;

namespace Ebony_and_Ivory
{
    internal class Program
    {
        private static readonly StreamReader reader = new StreamReader(Console.OpenStandardInput(1024*10), Encoding.ASCII, false, 1024*10);
        private static readonly StreamWriter writer = new StreamWriter(Console.OpenStandardOutput(1024*10), Encoding.ASCII, 1024*10);

        private static void Main(string[] args)
        {
            writer.WriteLine(Solve() ? "Yes" : "No");
            writer.Flush();
        }

        private static bool Solve()
        {
            int a = Next();
            int b = Next();
            int c = Next();

            for (int i = 0; i <= c; i += a)
            {
                if ((c - i)%b == 0)
                    return true;
            }
            return false;
        }

        private static int Next()
        {
            int c;
            int res = 0;
            do
            {
                c = reader.Read();
                if (c == -1)
                    return res;
            } while (c < '0' || c > '9');
            res = c - '0';
            while (true)
            {
                c = reader.Read();
                if (c < '0' || c > '9')
                    return res;
                res *= 10;
                res += c - '0';
            }
        }
    }
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

namespace ConsoleApplication5
{
    class Program
    {
        static void Main(string[] args)
        {
            long first = MyConsoleInputStreamParser.GetLong, second = MyConsoleInputStreamParser.GetLong, all = MyConsoleInputStreamParser.GetLong;
            var answerFind = false;
            long i = 0;
            while (i * first <= all)
            {
                long g = 0;
                while (i * first + g * second < all)
                    g++;
                if (i * first + g * second == all)
                {
                    answerFind = true;
                    break;
                }
                i++;
            }
            if (answerFind)
                Console.WriteLine("Yes");
            else
                Console.WriteLine("No");
        }

        public static class MyConsoleInputStreamParser
        {
            private static TextReader reader = new StreamReader(Console.OpenStandardInput());
            private static Queue<string> currentLineStrings = new Queue<string>();

            public static string GetLine { get { return reader.ReadLine(); } }

            public static string GetString { get { while (currentLineStrings.Count == 0) currentLineStrings = new Queue<string>(GetStringArray); return currentLineStrings.Dequeue(); } }

            public static int GetInt { get { return int.Parse(GetString); } }

            public static long GetLong { get { return long.Parse(GetString); } }

            public static double GetDouble { get { return double.Parse(GetString, CultureInfo.InvariantCulture); } }

            public static char[] GetCharArray { get { return GetLine.ToCharArray(); } }

            public static string[] GetStringArray { get { return GetLine.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries); } }

            public static int[] GetIntArray { get { return GetStringArray.Select(int.Parse).ToArray(); } }

            public static long[] GetLongArray { get { return GetStringArray.Select(long.Parse).ToArray(); } }

            public static double[] GetDoubleArray { get { return GetStringArray.Select(s => double.Parse(s, CultureInfo.InvariantCulture)).ToArray(); } }

            public static char[][] ReturnCharMatrix(int numberOfRows) { char[][] matrix = new char[numberOfRows][]; for (int i = 0; i < numberOfRows; i++) matrix[i] = GetCharArray; return matrix; }

            public static string[][] ReturnStringMatrix(int numberOfRows) { string[][] matrix = new string[numberOfRows][]; for (int i = 0; i < numberOfRows; i++) matrix[i] = GetStringArray; return matrix; }

            public static int[][] ReturnIntMatrix(int numberOfRows) { int[][] matrix = new int[numberOfRows][]; for (int i = 0; i < numberOfRows; i++) matrix[i] = GetIntArray; return matrix; }

            public static long[][] ReturnLongMatrix(int numberOfRows) { long[][] matrix = new long[numberOfRows][]; for (int i = 0; i < numberOfRows; i++) matrix[i] = GetLongArray; return matrix; }

            public static double[][] ReturnDoubleMatrix(int numberOfRows) { double[][] matrix = new double[numberOfRows][]; for (int i = 0; i < numberOfRows; i++) matrix[i] = GetDoubleArray; return matrix; }
        }
    }
}

using System;
using System.IO;
using System.Collections.Generic;
using System.Linq;
using System.Data;
using System.Numerics;

namespace ConsoleApplication1
{
    class Program : ProgramBase
    {
        private const long commonMod = 1000000007;
        private int index = 0;
        static void Main(string[] args)
        {
            var p = new Program();
            var x = p.Get();
            p.Out(x);
        }
        class Cut
        {
            public int a;
            public int b;
            public int line;
        }

        object Get()
        {
            checked
            {
                var inp = ReadLongs();
                var a = inp[0];
                var b = inp[1];
                var c = inp[2];
                for (int i = 0; i <= c; i++)
                    if (i % a == 0 && (c - i) % b == 0)
                        return "Yes";
                return "No";
            }
        }

        object Get2()
        {
            FileName = "strange";
            checked
            {
                var s = Read();
                var first = GetNext(s);
                var second = GetNext(s);
                var single = new Dictionary<char, int>();
                var twin = new Dictionary<Tuple<char, char>, List<Tuple<long, long>>>();
                single[first.Item1] = first.Item2;
                if (second == null)
                    return first.Item2;
                do
                {
                    if (!single.ContainsKey(second.Item1) || single[second.Item1] < second.Item2)
                        single[second.Item1] = second.Item2;
                    var pair = Tuple.Create(first.Item1, second.Item1);
                    if (!twin.ContainsKey(pair))
                        twin[pair] = new List<Tuple<long, long>>();
                    twin[pair].Add(Tuple.Create((long)first.Item2, (long)second.Item2));
                    first = second;
                    second = GetNext(s);
                } while (second != null);
                long result = single.Select(x => x.Value).Sum();
                foreach (var kv in twin)
                    result += ProcessPair(kv.Value);
                return result;
            }
        }

        public long ProcessPair(List<Tuple<long, long>> counts)
        {
            checked
            {
                var sorted = counts.OrderByDescending(x => x.Item1).ThenByDescending(x => x.Item2).ToArray();
                var filtered = new List<Tuple<long, long>>() { sorted[0] };
                for (int i = 1; i < sorted.Length; i++)
                    if (sorted[i].Item2 > filtered.Last().Item2)
                        filtered.Add(sorted[i]);

                var previous = filtered[0];
                var result = previous.Item1 * previous.Item2;
                for (int i = 1; i < filtered.Count; i++)
                    result += (filtered[i].Item2 - previous.Item2) * filtered[i].Item1;
                return result;
            }
        }

        public Tuple<char, int> GetNext(string s)
        {
            if (index == s.Length)
                return null;
            var ch = s[index];
            var count = 0;
            while (index < s.Length && ch == s[index])
            {
                count++;
                index++;
            }
            return Tuple.Create(ch, count);
        }

        public double ProcessPair(long[] a, long[] b, int p)
        {
            return ((double)NumberOfDivs(a, p) * 2000) / Count(a) +
                ((double)NumberOfDivs(b, p) * 2000) / Count(b) -
                ((double)(NumberOfDivs(a, p) * NumberOfDivs(b, p))) * 2000 / (Count(a) * Count(b));
        }

        public long NumberOfDivs(long[] a, int p)
        {
            return a[1] / p - (a[0] - 1) / p;
        }

        public long Count(long[] a)
        {
            return a[1] - a[0] + 1;
        }

        bool DoubleEquals(double a, double b)
        {
            return Math.Abs(a - b) < 0.0000000001;
        }

        bool SameLine(double[] a, double[] b, double[] c)
        {
            var x = a[0];
            var y = a[1];
            var x1 = b[0];
            var y1 = b[1];
            var x2 = c[0];
            var y2 = c[1];
            return DoubleEquals((x - x1) * (y2 - y1), (y - y1) * (x2 - x1));
        }

        double Distance(double[] a, double[] b)
        {
            return Math.Sqrt((a[0] - b[0]) * (a[0] - b[0]) + (a[1] - b[1]) * (a[1] - b[1]));
        }

        object Get7()
        {
            checked
            {
                var m = ReadInt();
                var p = ReadLongs();
                var arr = p.GroupBy(x => x).Select(g => new { g.Key, Count = g.Count() }).ToArray();
                var even = arr.Where(x => (x.Count & 1) == 0).FirstOrDefault();
                if (even != null)
                {
                    var index = Array.IndexOf(arr, even);
                    //arr[index].Count = arr[index].Count / 2;
                }
                long divs = 1;
                long result = 1;
                foreach (var a in arr)
                {
                    var pi = a.Key;
                    var curr = pi;
                    var olddivs = divs;
                    var oldres = result;
                    for (int i = 0; i < a.Count; i++)
                    {
                        result = (result * oldres % commonMod) * FastPow(curr, olddivs, commonMod) % commonMod;
                        curr = curr * pi % commonMod;
                        divs = (divs + olddivs) % (commonMod - 1);
                    }
                }
                return result;
            }
        }

        public long FastPow(long x, BigInteger pow, long mod)
        {
            if (pow == 0)
                return 1;
            if ((pow & 1) == 0)
                return FastPow(x * x % mod, pow / 2, mod);
            return x * FastPow(x, pow - 1, mod) % mod;
        }

        //object Get3()
        //{
        //    FileName = "";
        //    checked
        //    {
        //        var n = ReadInt();
        //        var hor = new List<Cut>();
        //        var ver = new List<Cut>();
        //        for (int i = 0; i < n; i++)
        //        {
        //            var a = ReadInts();
        //            if (a[0] == a[2])
        //                ver.Add(new Cut() { a = Math.Min(a[1], a[3]), b = Math.Max(a[1], a[3]), line = a[0] });
        //            else
        //                hor.Add(new Cut() { a = Math.Min(a[0], a[2]), b = Math.Max(a[0], a[2]), line = a[1] });
        //        }
        //        ver = Merge(ver);
        //        hor = Merge(hor);

        //    }
        //}

        List<Cut> Merge(List<Cut> l)
        {
            var a = l.OrderBy(x => x.line).ThenBy(x => x.a).ToArray();
            Cut previous = null;
            var result = new List<Cut>();
            for (int i = 0; i < a.Length; i++)
                if (previous == null)
                    previous = a[i];
                else
                    if (previous.line == a[i].line && previous.b >= a[i].a)
                        previous.b = Math.Max(previous.b, a[i].b);
                    else
                    {
                        result.Add(previous);
                        previous = a[i];
                    }
            if (previous != null)
                result.Add(previous);
            return result;
        }

    }
    abstract class ProgramBase
    {
        bool? prod = null;
        StreamReader f;
        protected string FileName { private get; set; }

        protected string Read()
        {
            if (string.IsNullOrEmpty(FileName))
                return Console.ReadLine();
            if (f == null)
                f = new StreamReader((GetProd() ? "" : "c:\\dev\\") + FileName + ".in");
            return f.ReadLine();
        }

        protected int ReadInt()
        {
            return Convert.ToInt32(Read());
        }
        protected int[] ReadInts()
        {
            return Read().Split(' ').Select(x => Convert.ToInt32(x)).ToArray();
        }

        protected long ReadLong()
        {
            return Convert.ToInt64(Read());
        }

        protected long[] ReadLongs()
        {
            return Read().Split(' ').Select(x => Convert.ToInt64(x)).ToArray();
        }

        public void Out(object r)
        {
            if (string.IsNullOrEmpty(FileName))
                Console.WriteLine(r);
            else if (GetProd())
                File.WriteAllText(FileName + ".out", r.ToString());
            else
                Console.WriteLine(r);
        }

        private bool GetProd()
        {
            if (!prod.HasValue)
                try
                {
                    prod = Environment.MachineName != "RENADEEN-NB-W7";
                }
                catch (Exception)
                {
                    prod = true;
                }
            return prod.Value;
        }
    }

    public static class Huj
    {
        public static T MinBy<T>(this IEnumerable<T> source, Func<T, double> func) where T : class
        {
            T result = null;
            var min = double.MaxValue;
            foreach (var item in source)
            {
                var current = func(item);
                if (min > current)
                {
                    min = current;
                    result = item;
                }
            }
            return result;
        }

        public static T MaxBy<T>(this IEnumerable<T> source, Func<T, double> func)
        {
            T result = default(T);
            var max = double.MinValue;
            foreach (var item in source)
            {
                var current = func(item);
                if (max < current)
                {
                    max = current;
                    result = item;
                }
            }
            return result;
        }

        public static string JoinStrings(this IEnumerable<string> source, string delimeter)
        {
            return string.Join(delimeter, source.ToArray());
        }
    }
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

namespace CodeForces
{
    public class CodeForces
    {
        static void Main(string[] args)
        {
            //var n = int.Parse(Console.ReadLine());
            var arr = GetArray();
            var a = arr[0];
            var b = arr[1];
            var c = arr[2];
            Console.WriteLine(Solve(a,b,c) ? "Yes" : "No");
        }

        public static void Tests()
        {
            //\
        }

        public static bool Solve(int a, int b, int c)
        {

            if (c >= a)
            {
                var m = c / a;

                for (var i = 1; i <= m; i++)
                {
                    if ((c - (a * i)) % b == 0)
                        return true;
                }
            }
            if (c >= b)
            {
                var m = c / b;
                for (var i = 1; i <= m; i++)
                {
                    if ((c - (b * i)) % a == 0)
                        return true;
                }
            }
            return false;
        }

        static int[] GetArray()
        {

            return Array.ConvertAll(Console.ReadLine().Split(), Convert.ToInt32);
        }

    }
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;

namespace codeforces
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] input = Console.ReadLine().Split(' ');
            int a = Convert.ToInt32(input[0]);
            int b = Convert.ToInt32(input[1]);
            int c = Convert.ToInt32(input[2]);
            for (int i = 0; a * i <= c; i++)
            {
                int a1 = a * i;
                int b1 = c - a1;
                if (b1 % b == 0)
                {
                    Console.WriteLine("Yes");
                    return;
                }
            }
            Console.WriteLine("No");
        }
    }
}

using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Resources;
using System.Text;

namespace Codeforces
{
	class Program
	{
		static void Main(string[] args)
		{
			string input1 = Console.ReadLine();
			//string input2 = Console.ReadLine();

			//string input3 = Console.ReadLine();
			//string input4 = Console.ReadLine();

			var inputs1 = input1.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).Select(long.Parse).ToArray();
			//var inputs2 = input2.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).Select(long.Parse).ToArray();

			long a = inputs1[0];
			long b = inputs1[1];
			long c = inputs1[2];

			for (long i = 0; i <= c / a; i++)
			{
				if ((c - i * a) % b == 0)
				{
					Console.WriteLine("Yes");
					return;
				}
			}

			Console.WriteLine("No");
		}

		public static void Print(int[] number)
		{
			var stringBuilder = new StringBuilder();
			foreach (var i in number)
			{
				if (i == 0 && stringBuilder.Length == 0)
				{
					continue;
				}

				stringBuilder.Append(i);
			}

			Console.WriteLine(stringBuilder.ToString());
		}

		public void Method1(ref int n1, ref int n2, ref int k1, ref int k2)
		{
			double a = (double)n1 / k1;
			double b = (double)n2 / k2;
			if (n1 >= n2 || (a >= b && a < 2 * b))
			{

			}
		}

		public void Method2(ref int n1, ref int n2, ref int k1, ref int k2)
		{
			double a = (double)n1 / k1;
			double b = (double)n2 / k2;
			if (n2 >= n1 || (b >= a && b < 2 * a))
			{

			}
		}

		public class Node
		{
			public int Count { get; set; }

			public int FirstIndex { get; set; } = -1;

			public int LastIndex { get; set; } = -1;
		}

		//public class Node<T>
		//{
		//	public Node<T> Left { get; set; }

		//	public Node<T> Right { get; set; }

		//	public T Value { get; set; }

		//	public Node(T value)
		//	{
		//		Value = value;
		//	}
		//}

		//public class Tree<T>
		//{
		//	public Node<T> Root { get; set; }

		//	public Tree(T value)
		//	{
		//		Root = new Node<T>(value);
		//	}
		//}

		private static long GCD(long a, long b)
		{
			long max = Math.Max(a, b);
			long min = Math.Min(a, b);

			if (min == 0)
			{
				return max;
			}

			a = min;
			b = max % min;
			return GCD(a, b);
		}

		private static long LCM(long a, long b)
		{
			return Math.Abs(a * b) / GCD(a, b);
		}

		//private static int Length(short[] a)
		//{
		//	int firstItemIndex = 0;
		//	for (int i = 0; i < a.Length; i++)
		//	{
		//		if (a[i] == 0)
		//		{
		//			continue;
		//		}

		//		firstItemIndex = i;
		//		break;
		//	}

		//	return a.Length - firstItemIndex;
		//}

		//private static short[] Subtract(short[] a, short[] b)
		//{
		//	if (a.Length != b.Length)
		//	{
		//		throw new ArgumentException();
		//	}

		//	short[] result = new short[a.Length];
		//	Array.Copy(a, result, a.Length);
		//	for (int i = result.Length - 1; i >= 0; i--)
		//	{
		//		if (result[i] < b[i])
		//		{
		//			int j = i - 1;
		//			while (result[j] == 0)
		//			{
		//				result[j--] = 9;
		//			}

		//			result[j]--;
		//			result[i] += 10;
		//		}

		//		result[i] -= b[i];
		//	}

		//	return result;
		//}

		//private static short[] Multiply(short[] a, int b)
		//{
		//	short[] result = new short[a.Length];
		//	for (int i = a.Length - 1; i > 0; i--)
		//	{
		//		int temp = a[i] * b;
		//		result[i] = (short)(result[i] + temp % 10);
		//		result[i - 1] = (short)(result[i - 1] + temp / 10);
		//	}

		//	return result;
		//}

		//private static int Mod(short[] a, int b)
		//{
		//	int rest = 0, i = 0;
		//	while (i < a.Length)
		//	{
		//		int d = 10 * rest + a[i];
		//		while (d < b && i < a.Length - 1)
		//		{
		//			d = 10 * d + a[++i];
		//		}

		//		rest = d % b;
		//		i++;
		//	}

		//	return rest;
		//}

		//private static short[] Divide(short[] a, int b)
		//{
		//	short[] result = new short[a.Length];
		//	int rest = 0, i = 0;
		//	while (i < a.Length)
		//	{
		//		int d = 10 * rest + a[i];
		//		while (d < b && i < a.Length - 1)
		//		{
		//			d = 10 * d + a[++i];
		//		}

		//		result[i] = (short)(d / b);
		//		rest = d % b;
		//		i++;
		//	}

		//	return result;
		//}
	}
}

using System;

class Program
{
    static void Main(string[] args)
    {
        var inp = Console.ReadLine().Split(' ');
        int a = int.Parse(inp[0]);
        int b = int.Parse(inp[1]);
        int c = int.Parse(inp[2]);

        if (c % a == 0 || c % b == 0)
            Console.WriteLine("Yes");
        else
        {
            for (; c >= 0; c -= a)
            {
                if (c % b == 0)
                {
                    Console.WriteLine("Yes");
                    Console.ReadLine();
                    return;
                }
            }
            Console.WriteLine("No");
        }
        Console.ReadLine();
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            var data = Console.ReadLine().Split().Select(int.Parse).ToArray();
            var a = data[0];
            var b = data[1];
            var c = data[2];
            for (int i = 0; i <= c; i++)
            {
                for (int j = 0; j <= c; j++)
                {
                    if (a*i + b*j == c)
                    {
                        Console.WriteLine("Yes");
                        return;
                    }
                }
            }
            Console.WriteLine("No");
        }

        static int Gcd(int a, int b)
        {
            if (b == 0)
                return a;
            return Gcd(b, a%b);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace codeforces
{
	class MainClass
	{
		public static void Main (string[] args)
		{
			string[] s = Console.ReadLine ().Split (' ');
			int a = int.Parse (s [0]);
			int b = int.Parse (s [1]);
			int c = int.Parse (s [2]);
			bool bb = false;
			for (int n = 0; n <= c/a; n++)
				for (int m = 0; m <= c/b; m++)
					if (n * a + m * b == c) {
						bb = true;
						break;
					}
			if(bb)
				Console.WriteLine ("YES");
			else
				Console.WriteLine ("NO");
		}
	}
}

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Globalization;

#if DEBUG
using System.Diagnostics;
#endif

namespace CompetitiveProgramming
{
    class Program
    {
        static bool s_IsMultipleTestCases = false;
        static void Main(string[] args)
        {
#if DEBUG
            var streamReader = new StreamReader("../../input.txt", Encoding.ASCII, false, 32768);
            var streamWriter = new StreamWriter("../../output.txt", false, Encoding.ASCII, 32768);
            var timer = new Stopwatch();
            timer.Start();
#else
            var streamReader = new StreamReader(Console.OpenStandardInput(32768), Encoding.ASCII, false, 32768);
            var streamWriter = new StreamWriter(Console.OpenStandardOutput(32768), Encoding.ASCII, 32768);
#endif
            var reader = new InputReader(streamReader);

            var numberOfTest = 1;
            if (s_IsMultipleTestCases)
            {
                numberOfTest = reader.NextInt();
            }
            for (var testNumber = 1; testNumber <= numberOfTest; ++testNumber)
            {
                Task solver = new Task();
                solver.Solve(testNumber, reader, streamWriter);
            }
#if DEBUG
            streamWriter.WriteLine("\nEslapsed Time: " + timer.ElapsedMilliseconds + " ms");
#endif
            streamReader.Close();
            streamWriter.Close();
        }
    }

    class Task
    {
        const int MAXN = 100;
        long ans = 0;
        string res = string.Empty;
        public void Solve(int testNumber, InputReader reader, StreamWriter writer)
        {
            var a = reader.NextInt();
            var b = reader.NextInt();
            var c = reader.NextInt();

            res = "No";
            for (int i = 0; i * a <= c; i++)
            {
                for (int j = 0; j * b + i * a <= c; j++)
                {
                    if (j * b + i * a == c)
                    {
                        res = "Yes";
                        break;
                    }
                }
                if (res == "Yes") break;
            }
            writer.WriteLine(res);
        }

        #region Utilities
        private string ConvertArrayToString(int[] arrs)
        {
            var sb = new StringBuilder();
            foreach (var item in arrs)
            {
                sb.Append(item);
                sb.Append("\n");
            }
            return sb.ToString();
        }

        private string ConvertArrayToString(long[] arrs)
        {
            var sb = new StringBuilder();
            foreach (var item in arrs)
            {
                sb.Append(item);
                sb.Append("\n");
            }
            return sb.ToString();
        }

        private string ConvertDoubleToString(double x)
        {
            return x.ToString(CultureInfo.InvariantCulture);
        }

        private int Max(int a, int b)
        {
            return Math.Max(a, b);
        }

        private int Min(int a, int b)
        {
            return Math.Min(a, b);
        }

        private long Max(long a, long b)
        {
            return Math.Max(a, b);
        }

        private long Min(long a, long b)
        {
            return Math.Min(a, b);
        }

        private long GCD(long a, long b)
        {
            return a > 0 ? b : GCD(b, a % b);
        }

        private int GCD(int a, int b)
        {
            return a > 0 ? b : GCD(b, a % b);
        }

        #endregion
    }

    class InputReader
    {
        private char[] _inbuf;
        private int _lenbuf = 0, _ptrbuf = 0;
        private StreamReader _reader;

        public InputReader(StreamReader reader)
        {
            _reader = reader;
            _inbuf = new char[1024];
            _lenbuf = 0;
            _ptrbuf = 0;
        }

        private int ReadByte()
        {
            if (_lenbuf == -1)
                throw new Exception();
            if (_ptrbuf >= _lenbuf)
            {
                _ptrbuf = 0;
                try
                {
                    _lenbuf = _reader.Read(_inbuf, 0, 1024);
                }
                catch (IOException e)
                {
                    throw e;
                }
                if (_lenbuf <= 0)
                    return -1;
            }
            return _inbuf[_ptrbuf++];
        }

        private bool IsSpaceChar(int c)
        {
            return !(c >= 33 && c <= 126);
        }

        private int Skip()
        {
            int b;
            while ((b = ReadByte()) != -1 && IsSpaceChar(b)) ;
            return b;
        }

        public int NextInt()
        {
            int num = 0, b;
            var minus = false;
            while ((b = ReadByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
            if (b == '-')
            {
                minus = true;
                b = ReadByte();
            }

            while (true)
            {
                if (b >= '0' && b <= '9')
                {
                    num = num * 10 + (b - '0');
                }
                else
                {
                    return minus ? -num : num;
                }
                b = ReadByte();
            }
        }

        public long NextLong()
        {
            long num = 0, b;
            var minus = false;
            while ((b = ReadByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
            if (b == '-')
            {
                minus = true;
                b = ReadByte();
            }

            while (true)
            {
                if (b >= '0' && b <= '9')
                {
                    num = num * 10 + (b - '0');
                }
                else
                {
                    return minus ? -num : num;
                }
                b = ReadByte();
            }
        }

        public string Next()
        {
            var b = Skip();
            var sb = new StringBuilder();
            while (!(IsSpaceChar(b)))
            {
                sb.Append((char)b);
                b = ReadByte();
            }
            return sb.ToString();
        }

        public double NextDouble()
        {
            return double.Parse(Next(), CultureInfo.InvariantCulture);
        }

        public int[] NIS(int n)
        {
            var arrs = new int[n];
            for (int i = 0; i < n; i++)
            {
                arrs[i] = NextInt();
            }
            return arrs;
        }

        public long[] NLS(int n)
        {
            var arrs = new long[n];
            for (int i = 0; i < n; i++)
            {
                arrs[i] = NextLong();
            }
            return arrs;
        }
    }

}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Text.RegularExpressions;
using System.IO;
using System.Numerics;
using System.Globalization;
using System.Threading;

namespace probleme {
    class Program {
        static void Main(string[] args) {
            //Console.SetIn(new StreamReader("file.txt"));
            string[] s = Console.ReadLine().Split(' ');
            int a = int.Parse(s[0]), b = int.Parse(s[1]), c = int.Parse(s[2]);
            bool sol = false;
            for (int i = 0; i * a <= c; i++) {
                int r = c - i * a;
                if (r % b == 0) {
                    sol = true;
                    break;
                }
            }
            if (sol) {
                Console.Write("YES");
            } else {
                Console.Write("NO");
            }
            //Console.ReadKey();
        }
    }
}

using System;
using System.Globalization;
using System.IO;
using System.Linq;

namespace CF317
{
	internal class Program
	{
		private static void Main(string[] args)
		{
			var sr = new InputReader(Console.In);
			//var sr = new InputReader(new StreamReader("input.txt"));
			var task = new Task();
			using (var sw = Console.Out) {
				task.Solve(1, sr, sw);
				//Console.ReadKey();
			}
		}
	}

	internal class Task
	{
		public void Solve(int testNumber, InputReader sr, TextWriter sw)
		{
			var input = sr.ReadArray(Int32.Parse);
			var a = input[0];
			var b = input[1];
			var c = input[2];
			if (c % a == 0) {
				sw.WriteLine("Yes");
				return;
			}
			if (c % b == 0) {
				sw.WriteLine("Yes");
				return;
			}
			if (c % (a + b) == 0) {
				sw.WriteLine("Yes");
				return;
			}
			if (c < a && c < b) {
				sw.WriteLine("No");
				return;
			}
			var max = 10001;
			var dp = new bool[3, max];
			dp[0, 0] = true;
			for (var i = a; i < max; i += a)
				dp[0, i] = true;
			for (var i = 0; i < max; i++) {
				if (i % b == 0)
					dp[1, i] = true;
				else
					dp[1, i] = dp[0, i];
			}
			for (var k = 0; k < max; k++) {
				if (k >= b || k >= a) {
					dp[2, k] = dp[1, k];
					if (k >= b)
						dp[2, k] = dp[2, k] || dp[1, k - b] || dp[2, k - b];
					if (k >= a)
						dp[2, k] = dp[2, k] || dp[1, k - a] || dp[2, k - a];
				}
				else
					dp[2, k] = dp[1, k];
			}
			sw.WriteLine(dp[2, c] ? "Yes" : "No");
		}
	}

	internal class InputReader : IDisposable
	{
		private bool isDispose;
		private readonly TextReader sr;

		public InputReader(TextReader stream)
		{
			sr = stream;
		}

		public void Dispose()
		{
			Dispose(true);
			GC.SuppressFinalize(this);
		}

		public string NextString()
		{
			var result = sr.ReadLine();
			return result;
		}

		public int NextInt32()
		{
			return Int32.Parse(NextString());
		}

		public long NextInt64()
		{
			return Int64.Parse(NextString());
		}

		public string[] NextSplitStrings()
		{
			return NextString()
				.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
		}

		public T[] ReadArray<T>(Func<string, CultureInfo, T> func)
		{
			return NextSplitStrings()
				.Select(s => func(s, CultureInfo.InvariantCulture))
				.ToArray();
		}

		protected void Dispose(bool dispose)
		{
			if (!isDispose) {
				if (dispose)
					sr.Close();
				isDispose = true;
			}
		}

		~InputReader()
		{
			Dispose(false);
		}
	}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace OlimpA
{
    class Program
    {
        static void Main(string[] args)
        {
            string s = Console.ReadLine();
            string[] words = s.Split(' ');

            int a = Convert.ToInt32(words[0]);
            int b = Convert.ToInt32(words[1]);
            int c = Convert.ToInt32(words[2]);
            int countX = 0,countY = 0;
            int check = 0;
            bool pos = false;

                while (check < c)
                {
                    countX++;
                    check = countX * a;
                }
                if (check == c)
                    pos = true;
                check = 0;
                while (check < c)
                {
                    countY++;
                    check = countY * b;
                }
                if (check == c)
                    pos = true;

                for (int i = 0; i <= countX; i++)
                    for (int j = 0; j <= countY;j++ )
                    {
                        if ((a * i + j * b) == c)
                        {
                            pos = true;
                            goto Final;
                        }

                    }

            Final:
                        if (pos)
                            Console.WriteLine("Yes");
                        else Console.WriteLine("No");

        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;

namespace ConsoleApplication1
{
    class Manthan1
    {
        static void Main(string[] args)
        {
            //Console.SetIn(new StreamReader(@"D:\Sergey\Code\1.txt"));

            string strT = Console.ReadLine();
            string[] strParams;
            strParams = strT.Split(new char[] { ' ' });
            int a = int.Parse(strParams[0]);
            int b = int.Parse(strParams[1]);
            int c = int.Parse(strParams[2]);

            if (c % a == 0 || c % b == 0)
            {
                Console.WriteLine("Yes");
                return;
            }

            int a1 = c / a;
            int b1 = c / b;
            int r = 1;

            int ca = a1 * a;
            int cb = b;
            //for (int i = a1, j = 1; i > 0 && j <= b1; i--, j ++)
            while (ca > 0)
            {
                if ((c - ca) % b == 0)
                {
                    Console.WriteLine("Yes");
                    return;
                }

                ca -= a;
            }

            Console.WriteLine("No");
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            String[] numbersString = Console.ReadLine().Split(' ');
            int a = Convert.ToInt32(numbersString[0]);
            int b = Convert.ToInt32(numbersString[1]);
            int c = Convert.ToInt32(numbersString[2]);

            bool temp = false;
            for (int i = 0; i <= c; i++)
            {
                for (int j = 0; j <= c; j++)
                {
                    if (temp == false)
                    {
                        int max = (i * a) + (j * b);
                        if (max == c)
                        {
                            temp = true;
                            break;
                        }
                        else if (max > c)
                        {
                            break;
                        }
                    }
                }
                if (temp == true)
                    break;
            }
            if (temp == true)
                Console.WriteLine("Yes");
            else
                Console.WriteLine("No");
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication2
{
    class Program
    {

        static void Main(string[] args)
        {
            string s = Console.ReadLine();
            string[] x = new string[3];
            int a, b, c;
            int j = 0;
            bool f=false;
            for (int i = 0; i < s.Length; i++)
            {if(s.ElementAt(i)==' ')
                {
                    j++;
                }
                x[j] += s.ElementAt(i);
            }
            a = int.Parse(x[0]);
            b = int.Parse(x[1]);
            c = int.Parse(x[2]);
            for(int i = 0; i <= c / a; i++)
            {
                for(int k = 0; k <= c / b; k++)
                {
                    if (i * a + k * b == c) { f = true; break; }

                }
            }
            if (f) Console.WriteLine("Yes");
            else Console.WriteLine("No");
        }
    }
}

using System;
using System.Collections.Generic;
using System.Collections;
using System.Linq;
using System.Numerics;

namespace contest
{

    class contest
    {

        static void Main(string[] args)
        {

            //int n = int.Parse(Console.ReadLine());
            //var input = Console.ReadLine().Split().Select(int.Parse).ToArray();

            //var num = Console.ReadLine().Split().Select(int.Parse).ToArray();

            var num = Console.ReadLine().Split().Select(int.Parse).ToArray();
            int a = num[0];
            int b = num[1];
            int c = num[2];

            int tmp = c;
            bool pos = false;
            if (c % a==0 || c % b==0) pos = true;
            while(tmp>=b)
            {
                if (divisible(tmp, a))
                {
                    pos = true;
                    break;
                }
                else tmp -= b;
            }
            if (!pos)
            {
                tmp = c;
                while (tmp >= a)
                {
                    if (divisible(tmp, b))
                    {
                        pos = true;
                        break;
                    }
                    else tmp -= a;
                }
            }
            Console.WriteLine((pos) ?"Yes" : "No");

            //Console.WriteLine();

            //Console.Read();

        }

        public static bool divisible(int c, int d)
        {
            return c % d == 0 ? true : false;
        }

    }

}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CF633A {
    class Program {
        static void Main(string[] args) {
            //a + b a linear combination of c?
            string[] input = Console.ReadLine().Split(' ');
            int a = Convert.ToInt32(input[0]);
            int b = Convert.ToInt32(input[1]);
            int c = Convert.ToInt32(input[2]);
            bool canDo = false;

            for(int x = 0; x * a <= c ; x++) {
                for(int y = 0; y * b <= c; y++) {
                    if(a*x + b*y == c) {
                        canDo = true;
                    }
                }
            }

            if(canDo) {
                Console.WriteLine("Yes");
            } else {
                Console.WriteLine("No");
            }
        }
    }
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;

namespace Codeforces
{
    class A
    {
        private static ThreadStart s_threadStart = new A().Go;
        private static bool s_time = false;
        private static double s_eps = 1e-16;

        private void Go()
        {
            int a = GetInt();
            int b = GetInt();
            int c = GetInt();

            int x = 0;
            while (x <= c)
            {
                if ((c - x) % b == 0)
                {
                    Wl("YES");
                    return;
                }
                x += a;
            }

            Wl("NO");
        }

        #region Template

        public static void Main(string[] args)
        {
            System.Diagnostics.Stopwatch timer = new System.Diagnostics.Stopwatch();
            Thread main = new Thread(new ThreadStart(s_threadStart), 200 * 1024 * 1024);
            timer.Start();
            main.Start();
            main.Join();
            timer.Stop();
            if (s_time)
                Wl(timer.ElapsedMilliseconds);
        }

        private static IEnumerator<string> ioEnum;
        private static string GetString()
        {
            while (ioEnum == null || !ioEnum.MoveNext())
            {
                ioEnum = Console.ReadLine().Split().AsEnumerable().GetEnumerator();
            }

            return ioEnum.Current;
        }

        private static int GetInt()
        {
            return int.Parse(GetString(), CultureInfo.InvariantCulture);
        }

        private static long GetLong()
        {
            return long.Parse(GetString(), CultureInfo.InvariantCulture);
        }

        private static double GetDouble()
        {
            return double.Parse(GetString(), CultureInfo.InvariantCulture);
        }

        private static List<int> GetIntArr(int n)
        {
            List<int> ret = new List<int>(n);
            for (int i = 0; i < n; i++)
            {
                ret.Add(GetInt());
            }
            return ret;
        }

        private static void Wl<T>(T o)
        {
            if (o is double)
            {
                Wld((o as double?).Value, "");
            }
            else if (o is float)
            {
                Wld((o as float?).Value, "");
            }
            else
                Console.WriteLine(o.ToString());
        }

        private static void Wl<T>(IEnumerable<T> enumerable)
        {
            Wl(string.Join(" ", enumerable.Select(e => e.ToString()).ToArray()));
        }

        private static void Wld(double d, string format)
        {
            Wl(d.ToString(format, CultureInfo.InvariantCulture));
        }

        #endregion
    }
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Globalization;

namespace Codeforces
{
    class Program
    {

        #region input

        static long readLong() {
            long num;
            long.TryParse(Console.ReadLine(),out num);
            return num;
        }

        static ulong readULong() {
            ulong num;
            ulong.TryParse(Console.ReadLine(),out num);
            return num;
        }

        static int readInt() {
            int num;
            int.TryParse(Console.ReadLine(),out num);
            return num;
        }

        static bool readBool() {
            int num;
            int.TryParse(Console.ReadLine(),out num);
            return num != 0;
        }

        static long[] readLongs() {
            string[] nums = Console.ReadLine().Split(new char[] { ' ' });
            long[] parsed = new long[nums.Length];
            for(int i = 0; i < nums.Length; i++) {
                long.TryParse(nums[i],out parsed[i]);
            }
            return parsed;
        }

        static int[] readInts() {
            string[] nums = Console.ReadLine().Split(new char[] { ' ' });
            int[] parsed = new int[nums.Length];
            for(int i = 0; i < nums.Length; i++) {
                int.TryParse(nums[i],out parsed[i]);
            }
            return parsed;
        }

        static void readInts(out int a,out int b) {
            string[] nums = Console.ReadLine().Split(new char[] { ' ' });
            int[] parsed = new int[nums.Length];
            int.TryParse(nums[0],out a);
            int.TryParse(nums[1],out b);
        }

        static BitArray readBools() {
            string[] nums = Console.ReadLine().Split(new char[] { ' ' });
            BitArray bits = new BitArray(nums.Length);
            for(int i = 0; i < nums.Length; i++) {
                if(nums[i] != "0") {
                    bits[i] = true;
                }
            }
            return bits;
        }

        static BitArray readBools(string off) {
            string[] nums = Console.ReadLine().Split(new char[] { ' ' });
            BitArray bits = new BitArray(nums.Length);
            for(int i = 0; i < nums.Length; i++) {
                if(nums[i] != off) {
                    bits[i] = true;
                }
            }
            return bits;
        }

        static void waist() {
            Console.ReadLine();
        }

        #endregion

        #region utility

        static int minIndex<T>(List<T> l) where T : IComparable {
            if(l == null || l.Count == 0) {
                return -1;
            }
            int min = 0;
            for(int i = 0; i < l.Count; i++) {
                if(l[i].CompareTo(l[min]) < 0) {
                    min = i;
                }
            }
            return min;
        }

        static int maxIndex<T>(List<T> l) where T : IComparable {
            if(l == null || l.Count == 0) {
                return -1;
            }
            int min = 0;
            for(int i = 0; i < l.Count; i++) {
                if(l[i].CompareTo(l[min]) > 0) {
                    min = i;
                }
            }
            return min;
        }

        static void print(List<int> l) {
            for(int i = 0; i < l.Count; i++) {
                if(i != 0) {
                    Console.Write(" ");
                }
                Console.Write((l[i]));
            }
            Console.WriteLine();
        }

        static long largeModolu(long a,long b,long m) {
            long prev = a;
            long sum = (b & 1) > 0 ? a : 1;
            int digits = (int)(Math.Ceiling(Math.Log(b,2)));
            for(int i = 1; i < digits; i++) {
                prev = (prev * prev) % (m);
                if((b & (1L << i)) > 0) {
                    sum = (sum * prev) % (m);
                }
            }
            return sum;
        }

        static long GCD(long a,long b) {
            long temp;
            if(a > b) {
                temp = b;
                b = a;
                a = temp;
            }
            while(b != 0) {
                temp = b;
                b = a % b;
                a = temp;
            }
            return a;
        }

        class SortableKVP<T> where T : IComparable
        {
            List<Tuple<int,T>> data { set; get; }

            public int count
            {
                get
                {
                    return data.Count;
                }
            }

            public T this[int index]
            {
                get
                {
                    return data[index].Item2;
                }
            }

            public int originalIndex(int sortedIndex) {
                return data[sortedIndex].Item1;
            }

            public void sort() {
                data.Sort((a,b) => a.Item2.CompareTo(b.Item2));
            }

            public void add(T item) {
                data.Add(new Tuple<int,T>(data.Count,item));
            }

            public void removeAt(int sortedIndex) {
                data.RemoveAt(sortedIndex);
            }

            public SortableKVP() {
                data = new List<Tuple<int,T>>();
            }

            public SortableKVP(T[] data) {
                this.data = new List<Tuple<int,T>>(data.Length);
                for(int i = 0; i < data.Length; i++) {
                    this.data.Add(new Tuple<int,T>(i,data[i]));
                }
            }
        }

        #endregion

        static void Main(string[] args) {
            int[] inp = readInts();
            for(int i = 0; inp[0] * i <= inp[2]; i++) {
                if((inp[2] - i * inp[0]) % inp[1] == 0) {
                    Console.WriteLine("Yes");
                    return;
                }
            }
            Console.WriteLine("No");
         }

        static void seven() {
            int x = readInt();
            int y = readInt();
            if(y == 0) {
                Console.Write(1);
                return;
            }
            long[] dp = new long[(int)(Math.Log(y,2) + 1)];
            long mult = 1;
            dp[0] = x;
            if((y & 1) == 1) {
                mult = dp[0];
            }
            for(int i = 1; i < dp.Length; i++) {
                dp[i] = dp[i-1] * dp[i - 1];
                if((y & (1 << i)) != 0) {
                    mult *= dp[i];
                }
            }
            Console.WriteLine(mult);

        }

        static void twelve() {
            int[] a = readInts();
            int[] b = readInts();
            int x = readInt();
            Dictionary<int,int> h = new Dictionary<int,int>();
            for(int i = 0; i < b.Length; i++) {
                h.Add(b[i],i);
            }
            for(int i = 0; i < a.Length; i++) {
                if(h.ContainsKey(x - a[i])) {
                    Console.Write(i + " " + h[x - a[i]]);
                    break;
                }
            }
        }

        static void ten() {
            int[] a = readInts();
            int[] b = readInts();
            int k = readInt();
            int i = 0, j = 0;
            for(int c = 0; c < k; c++) {
                if(i == a.Length || (j != b.Length && a[i] < b[j])) {
                    if(c == k - 1) {
                        Console.WriteLine(a[i]);
                    }
                    ++i;
                } else {
                    if(c == k - 1) {
                        Console.WriteLine(b[j]);
                    }
                    ++j;
                }
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace codeforces
{
	class Program
	{
		public class User
		{
			public int c;

			public int r;
		}

		public class Point
		{
			public int x;

			public int y;
		}

		public class StringInt
		{
			public string x;

			public int y;
		}

		public class SIComparer : IComparer<StringInt>
		{
			public int Compare(StringInt x, StringInt y)
			{
				return x.x.CompareTo(y.x);
			}
		}

		public class Comparer : IComparer<User>
		{
			public int Compare(User x, User y)
			{
				if (x.c < y.c || (x.c == y.c && x.r < y.r))
					return -1;
				return 1;
			}
		}

		public static long getGcd(long a, long b)
		{
			if (b == 0)
				return a;
			return getGcd(b, a % b);
		}

		public static void WriteYESNO(bool x, string yes = "YES", string no = "NO")
		{
			if (x)
				Console.WriteLine(yes);
			else
			{
				Console.WriteLine(no);
			}
		}

		public static string getString()
		{
			return Console.ReadLine();
		}

		public static List<int> getList()
		{
			var s = Console.ReadLine();
			return s.Split(' ').Select(int.Parse).ToList();
		}

		public static List<long> getLongList()
		{
			var s = Console.ReadLine();
			return s.Split(' ').Select(long.Parse).ToList();
		}

		public static int Min(int x, int y)
		{
			return Math.Min(x, y);
		}

		public static int Max(int x, int y)
		{
			return Math.Max(x, y);
		}

		public static int Abs(int x)
		{
			return Math.Abs(x);
		}

		public static int getInt()
		{
			var s = Console.ReadLine();
			return int.Parse(s);
		}

		public static long getLong()
		{
			var s = Console.ReadLine();
			return long.Parse(s);
		}

		public class Edge
		{
			public int v;

			public int w;
		}

		public class Vertex
		{
			public List<Edge> edges;

			public int ct;

			public bool was;
		}

		public static bool isPrime(int x)
		{
			for (var i = 2; i * i <= x; ++i)
				if (x % i == 0)
					return false;
			return true;
		}

		private static void Main(string[] args)
		{
/*			var input = new StreamReader("input.txt");
			var output = new StreamWriter("output.txt");*/
			var l = getList();
			for (var i = 0; i * l[0] <= l[2]; ++i)
			{
				if ((l[2] - i * l[0]) % l[1] == 0)
				{
					Console.WriteLine("Yes");
					return;
				}
			}
			Console.WriteLine("No");
			Console.ReadLine();
		}
	}
}

using System;
using System.IO;
using System.Collections.Generic;
using System.Globalization;

class Program
{
    //////////////////////////////////////////////////

    void Solution()
    {
        var a = ri;
        var b = ri;
        var c = ri;
        for (int i = 0; i <= 10000; i++)
        {
            for (int j = 0; j <= 10000; j++)
            {
                if (a * i + b * j == c)
                {
                    wln("Yes");
                    return;
                }
            }
        }
        wln("No");
    }
    //////////////////////////////////////////////////

    static void swap(ref object o1, ref object o2) { var o = o1; o1 = o2; o2 = o; }
    static void wln(object o = null) { Console.WriteLine(o); }
    static void wsp(object o) { Console.Write(o+" "); }
    static void wrt(object o) { Console.Write(o); }
    //Console.Write(string.Format(CultureInfo.InvariantCulture, "{0:F12}", o));

    static long gcd(long a, long b) { return (b!=0) ? gcd(b, a % b) : a; }
    static long lcm(long a, long b) { return a / gcd(a, b) * b; }

    int ri
    {
        get
        {
            _read(); while (_str[_ind] == ' ') ++_ind;
            int sign = 1; if (_str[_ind] == '-') { sign = -1; ++_ind; } int p = 0;
            while (_ind < _count && _str[_ind] != ' ') p = p * 10 + _str[_ind++] - '0';
            while (_ind < _count && _str[_ind] == ' ') ++_ind; return p * sign;
        }
    }
    long rl
    {
        get
        {
            _read(); while (_str[_ind] == ' ') ++_ind;
            int sign = 1; if (_str[_ind] == '-') { sign = -1; ++_ind; } long p = 0;
            while (_ind < _count && _str[_ind] != ' ') p = p * 10 + _str[_ind++] - '0';
            while (_ind < _count && _str[_ind] == ' ') ++_ind; return p * sign;
        }
    }
    double rd
    {
        get
        {
            _read(); while (_str[_ind] == ' ') ++_ind; int sign = 1; if (_str[_ind] == '-') { sign = -1; ++_ind; }
            long p = 0, q = 1; while (_ind < _count && _str[_ind] != ' ' && _str[_ind] != '.') p = p * 10 + _str[_ind++] - '0';
            if (_ind < _count && _str[_ind] == '.') { ++_ind; while (_ind < _count && _str[_ind] != ' ') { p = p * 10 + _str[_ind++] - '0'; q *= 10; } }
            while (_ind < _count && _str[_ind] == ' ') ++_ind; return (double)p / q * sign;
        }
    }
    string rs
    {
        get
        {
            _read(); while (_ind < _count && _str[_ind] == ' ') ++_ind;
            var tmp = _str.IndexOf(' ', _ind);
            if (tmp == -1) { _count = 0; _ind = 0; return _str.Substring(_ind); }
            var s = _str.Substring(_ind, tmp - _ind); _ind = tmp + 1;
            while (_ind < _count && _str[_ind] == ' ') ++_ind; return s;
        }
    }

    int[] ria(int n)
    {
        var res = new int[n];
        for (int k = 0; k < n; )
        {
            var s = Console.ReadLine(); var m = s.Length;
            for (int i = 0; i < m && k < n; ++i)
            {
                while (i < m && s[i] == ' ') ++i; if (i == m) break; int sign = 1; if (s[i] == '-') { sign = -1; ++i; }
                int p = 0; while (i < m && s[i] != ' ') p = p * 10 + s[i++] - '0'; res[k++] = p * sign;
            }
        }
        _count = 0; _ind = 0; return res;
    }
    long[] rla(int n)
    {
        var res = new long[n];
        for (int k = 0; k < n; )
        {
            var s = Console.ReadLine(); var m = s.Length;
            for (int i = 0; i < m && k < n; ++i)
            {
                while (i < m && s[i] == ' ') ++i; if (i == m) break; int sign = 1; if (s[i] == '-') { sign = -1; ++i; }
                long p = 0; while (i < m && s[i] != ' ') p = p * 10 + s[i++] - '0'; res[k++] = p * sign;
            }
        }
        _count = 0; _ind = 0; return res;
    }
    double[] rda(int n)
    {
        var res = new double[n];
        for (int k = 0; k < n; )
        {
            var s = Console.ReadLine(); var m = s.Length;
            for (int i = 0; i < m && k < n; ++i)
            {
                while (i < m && s[i] == ' ') ++i; if (i == m) break; int sign = 1; if (s[i] == '-') { sign = -1; ++i; }
                long p = 0, q = 1; while (i < m && s[i] != ' ' && s[i] != '.') p = p * 10 + s[i++] - '0';
                if (i < m && s[i] == '.') { ++i; while (i < m && s[i] != ' ') { p = p * 10 + s[i++] - '0'; q *= 10; } }
                res[k++] = (double)p / q * sign;
            }
        }
        _count = 0; _ind = 0; return res;
    }
    string[] rsa(int n) { var res = new string[n]; for (int k = 0; k < n; ++k) res[k] = Console.ReadLine(); _count = 0; _ind = 0; return res; }
    string _str = null; int _count = 0; int _ind = 0;
    void _read() { if (_ind == _count) { _str = Console.ReadLine(); _count = _str.Length; _ind = 0; } }
    static void Main() { new Program().Solution(); }
}

using System;
using System.Linq;

namespace _633A
{
    class Program
    {
        static void Main()
        {
            var s = Console.ReadLine().Split().Select(int.Parse).ToArray();
            var a = s[0]; var b = s[1]; var c = s[2];
            int i = 0;
            bool exists = false;
            while (!exists && a * i <= c)
            {
                if ((c - a*i) % b == 0)
                {
                    exists = true;
                    break;
                }
                i++;
            }

            Console.WriteLine(exists? "Yes": "No");

        }
    }
}

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Numerics;

class Solution
{

    static void Main(String[] args)
    {
        int[] d = Console.ReadLine().Split(' ').Select(int.Parse).ToArray();
        decimal a = d[0], b = d[1], c = d[2];

        decimal x = c / a, y = c / b;
        bool flag = false;

        for (int i = 0; i <= x; i++)
        {
            for (int ii = 0; ii <= y; ii++)
            {
                if (a * i + b * ii == c)
                {
                    flag = true;
                    break;
                }
            }
            if (flag)
            {
                break;
            }
        }
        Console.WriteLine(flag ? "Yes" : "No");
        Console.ReadLine();

    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ebonyAndIvory
{
    class Program
    {
        static void Main(string[] args)
        {
            string input = Console.ReadLine();
            int a = Convert.ToInt32(input.Split()[0]);
            int b = Convert.ToInt32(input.Split()[1]);
            int c = Convert.ToInt32(input.Split()[2]);
            int aranan = 0;

                for (int i = 0; i <= 5000 ; i++)
                {
                    for (int j = 0; j <= 5000 ; j++)
                    {
                        aranan = i * a + j * b;
                        if (aranan == c)
                        {
                            Console.WriteLine("Yes");
                            return;
                        }
                        else if (aranan >= 10000)
                        {
                            break;
                        }
                    }
                }
            Console.WriteLine("No");

        }
    }
}

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;

// (づ°ω°)づﾐe★゜・。。・゜゜・。。・゜☆゜・。。・゜゜・。。・゜
public class Solver
{
    public void Solve()
    {
        int a = ReadInt();
        int b = ReadInt();
        int c = ReadInt();

        for (int i = 0; a * i <= c; i++)
            if ((c - i * a) % b == 0)
            {
                Write("Yes");
                return;
            }

        Write("No");
    }

    #region Main

    protected static TextReader reader;
    protected static TextWriter writer;
    static void Main()
    {
#if DEBUG
        reader = new StreamReader("..\\..\\input.txt");
        //reader = new StreamReader(Console.OpenStandardInput());
        writer = Console.Out;
        //writer = new StreamWriter("..\\..\\output.txt");
#else
        reader = new StreamReader(Console.OpenStandardInput());
        writer = new StreamWriter(Console.OpenStandardOutput());
        //reader = new StreamReader("input.txt");
        //writer = new StreamWriter("output.txt");
#endif
        try
        {
            //var thread = new Thread(new Solver().Solve, 1024 * 1024 * 128);
            //thread.Start();
            //thread.Join();
            new Solver().Solve();
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex);
#if DEBUG
#else
            throw;
#endif
        }
        reader.Close();
        writer.Close();
    }

    #endregion

    #region Read / Write
    private static Queue<string> currentLineTokens = new Queue<string>();
    private static string[] ReadAndSplitLine() { return reader.ReadLine().Split(new[] { ' ', '\t', }, StringSplitOptions.RemoveEmptyEntries); }
    public static string ReadToken() { while (currentLineTokens.Count == 0)currentLineTokens = new Queue<string>(ReadAndSplitLine()); return currentLineTokens.Dequeue(); }
    public static int ReadInt() { return int.Parse(ReadToken()); }
    public static long ReadLong() { return long.Parse(ReadToken()); }
    public static double ReadDouble() { return double.Parse(ReadToken(), CultureInfo.InvariantCulture); }
    public static int[] ReadIntArray() { return ReadAndSplitLine().Select(int.Parse).ToArray(); }
    public static long[] ReadLongArray() { return ReadAndSplitLine().Select(long.Parse).ToArray(); }
    public static double[] ReadDoubleArray() { return ReadAndSplitLine().Select(s => double.Parse(s, CultureInfo.InvariantCulture)).ToArray(); }
    public static int[][] ReadIntMatrix(int numberOfRows) { int[][] matrix = new int[numberOfRows][]; for (int i = 0; i < numberOfRows; i++)matrix[i] = ReadIntArray(); return matrix; }
    public static int[][] ReadAndTransposeIntMatrix(int numberOfRows)
    {
        int[][] matrix = ReadIntMatrix(numberOfRows); int[][] ret = new int[matrix[0].Length][];
        for (int i = 0; i < ret.Length; i++) { ret[i] = new int[numberOfRows]; for (int j = 0; j < numberOfRows; j++)ret[i][j] = matrix[j][i]; } return ret;
    }
    public static string[] ReadLines(int quantity) { string[] lines = new string[quantity]; for (int i = 0; i < quantity; i++)lines[i] = reader.ReadLine().Trim(); return lines; }
    public static void WriteArray<T>(IEnumerable<T> array) { writer.WriteLine(string.Join(" ", array)); }
    public static void Write(params object[] array) { WriteArray(array); }
    public static void WriteLines<T>(IEnumerable<T> array) { foreach (var a in array)writer.WriteLine(a); }
    private class SDictionary<TKey, TValue> : Dictionary<TKey, TValue>
    {
        public new TValue this[TKey key]
        {
            get { return ContainsKey(key) ? base[key] : default(TValue); }
            set { base[key] = value; }
        }
    }
    private static T[] Init<T>(int size) where T : new() { var ret = new T[size]; for (int i = 0; i < size; i++)ret[i] = new T(); return ret; }
    #endregion
}

/*
 * Created by SharpDevelop.
 * Handle: Arcos
 */
using System;
using System.Linq;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Text.RegularExpressions;

namespace TestingStuff
{
	class Program
	{
		public static void Main(string[] args)
		{
			var z = Console.ReadLine();
			List<int> x = new List<int>();
			foreach (String s in z.Split(' ') ){
				x.Add(int.Parse(s));
			}
			int a = x[0];
			int b = x[1];
			int c = x[2];
			int i = 0;
			int j = 0;

			for (i = 0; a*i <= c; i++){
				for (j = 0; b*j <= c; j++){
					if (a*i + b*j == c){
						Console.WriteLine("Yes");
						return;
					}
				}
			}

			Console.WriteLine("No");
			return;
		}
	}
}

using System;

namespace A633{
	class Program{
		static void Main(string[] args){
            int[] abc = Array.ConvertAll(Console.ReadLine().Split(' '), int.Parse);

            // a * x + b * y = c
            int ebonyShots = 0;
            int ivoryShots = 0;
            if(abc[2] % abc[0] == 0 || abc[2] % abc[1] == 0)
            {
                Console.WriteLine("Yes");
                return;
            }

            while (ebonyShots * abc[0] + ivoryShots * abc[1] < abc[2])
            {
                ebonyShots++;
                while (ebonyShots * abc[0] + ivoryShots * abc[1] < abc[2])
                {
                    ivoryShots++;
                }
                if (ebonyShots * abc[0] + ivoryShots * abc[1] == abc[2])
                {
                    Console.WriteLine("Yes");
                    return;
                } else
                {
                    ivoryShots = 0;
                }
            }
            Console.WriteLine("No");
		}
	}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication29
{

    class Program
    {

        static void Main(string[] args)
        {
            args = Console.ReadLine().Split();
            int a = int.Parse(args[0]);
            int b = int.Parse(args[1]);
            int c = int.Parse(args[2]);
            while (c > 0 && c % a != 0)
                c -= b;
            Console.WriteLine(c>=0? "Yes":"No");

        }
    }
}

using System;
using System.Linq;

namespace Codeforces
{
    internal static class Program
    {
        private static void Main()
        {
            var xs = Console.ReadLine().Split().Select(long.Parse).ToList();
            var a = xs[0];
            var b = xs[1];
            var c = xs[2];

            var maxI = c / a;
            var maxJ = c / b;

            for (var i = 0; i <= maxI; i++)
            {
                for (var j = 0; j <= maxJ; j++)
                {
                    if (a * i + b * j == c)
                    {
                        Console.WriteLine("Yes");
                        return;
                    }
                }
            }

            Console.WriteLine("No");
        }
    }
}

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Threading;

namespace Codeforces
{
    class Program : IDisposable
    {
        private static readonly TextReader textReader = new StreamReader(Console.OpenStandardInput());
        private static readonly TextWriter textWriter = new StreamWriter(Console.OpenStandardOutput());

        void Solve()
        {
            var str = Console.ReadLine().Split(' ');
            var a = int.Parse(str[0]);
            var b = int.Parse(str[1]);
            var c = int.Parse(str[2]);
            for (int i = 0; c-i*b>=0; ++i)
            {
                if ((c - i * b) % a == 0)
                {
                    Console.WriteLine("Yes");
                    return;
                }
            }
            Console.WriteLine("No");
            //Console.ReadLine();
        }

        static void Main(string[] args)
        {
            var p = new Program();
            p.Solve();
            p.Dispose();
        }

        #region Helpers

        private static int ReadInt()
        {
            return int.Parse(textReader.ReadLine());
        }

        private static long ReadLong()
        {
            return long.Parse(textReader.ReadLine());
        }

        private static int[] ReadIntArray()
        {
            return textReader.ReadLine().Split(' ').Select(int.Parse).ToArray();
        }
        #endregion

        public void Dispose()
        {
            textReader.Close();
            textWriter.Close();
        }
    }
}

using System;

namespace _A
{
	class MainClass
	{
		public static void Main (string[] args)
		{

			int[] Data = new int[3];

			string[] Temp;
			Temp = (Console.ReadLine ()).Split (' ');
			for (int i = 0; i < 3; i++){

				int x;
				int.TryParse(Temp[i], out x);
				Data[i] = x;

			}

			int T1 = Data[2];
			while (T1 > 0) {

				T1 = Data [2];
				T1 = T1 % Data [1];
				if (T1 > 0)
					Data[2] -= Data [0];

			}

			if (T1 == 0)
				Console.WriteLine ("Yes");
			else
				Console.WriteLine ("No");

			Console.ReadLine ();
		}
	}
}

using System;

namespace _A
{
	class MainClass
	{
		public static void Main (string[] args)
		{

			int[] Data = new int[3];

			string[] Temp;
			Temp = (Console.ReadLine ()).Split (' ');
			for (int i = 0; i < 3; i++){

				int x;
				int.TryParse(Temp[i], out x);
				Data[i] = x;

			}

			int T1 = Data[0];
			while (T1 > 0) {

				T1 = Data [0];
				T1 = T1 % Data [1];
				if (T1 > 0)
					Data[0] -= Data [2];

			}

			if (T1 == 0)
				Console.WriteLine ("Yes");
			else
				Console.WriteLine ("No");

			Console.ReadLine ();
		}
	}
}

using System;

namespace _A
{
	class MainClass
	{
		public static void Main (string[] args)
		{

			int[] Data = new int[3];

			string[] Temp;
			Temp = (Console.ReadLine ()).Split (' ');
			for (int i = 0; i < 3; i++){

				int x;
				int.TryParse(Temp[i], out x);
				Data[i] = x;

			}

			int T1 = Data[2];
			while (T1 > 0 && Data[2] > 0) {

				T1 = Data [2];
				T1 = T1 % Data [1];
				if (T1 > 0)
					Data[2] -= Data [0];

			}

			if (T1 == 0)
				Console.WriteLine ("Yes");
			else
				Console.WriteLine ("No");

			Console.ReadLine ();
		}
	}
}

using System;

namespace _A
{
	class MainClass
	{
		public static void Main (string[] args)
		{

			int[] Data = new int[4];

			string[] Temp;
			Temp = (Console.ReadLine ()).Split (' ');
			for (int i = 2; i >= 0; i--){

				int x;
				int.TryParse(Temp[2 - i], out x);
				Data[i] = x;

			}

			int T1 = Data[0]; Data [3] = Data [1] + Data [2];
			for (int i = 3; i >= 1 && T1 != 0; i--) {

				T1 = Data[0] % Data [i];

			}

			if (T1 == 0)
				Console.WriteLine ("Yes");
			else
				Console.WriteLine ("No");

			Console.ReadLine ();
		}
	}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {

            string[]y=Console.ReadLine().Split(' ');
            int a=int.Parse(y[0]);
            int b=int.Parse(y[1]);
            int n=int.Parse(y[2]);
            bool f=false;
            for(int i=0;i<1000;i++)
            {
                 for(int j=0;j<1000;j++)
                 if(a*i+b*j==n)
                 {
                      f=true;
                      break;

                 }
            }
            if(f)
            Console.WriteLine("YES");
            else
            Console.WriteLine("NO");
        }

    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {

            string[]y=Console.ReadLine().Split(' ');
            int a=int.Parse(y[0]);
            int b=int.Parse(y[1]);
            int n=int.Parse(y[2]);
            bool f=false;
            for(int i=0;i<100;i++)
            {
                 for(int j=0;j<100;j++)
                 if(a*i+b*j==n)
                 {
                      f=true;
                      break;

                 }
            }
            if(f)
            Console.WriteLine("YES");
            else
            Console.WriteLine("NO");
        }

    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {

            string[]y=Console.ReadLine().Split(' ');
            int a=int.Parse(y[0]);
            int b=int.Parse(y[1]);
            int n=int.Parse(y[2]);
            bool f=false;
            for(int i=0;i<5000;i++)
            {
                 for(int j=0;j<5000;j++)
                 if(a*i+b*j==n)
                 {
                      f=true;
                      break;

                 }
            }
            if(f)
            Console.WriteLine("YES");
            else
            Console.WriteLine("NO");
        }

    }
}

/*
 * User: ������
 * Date: 27.02.2016
 * Time: 15:49

A. Ҹ���� � �������
����������� �� ������� �� ����   2 �������
����������� �� ������ �� ����   256 ��������
����    ����������� ����
�����   ����������� �����
����� ��������� �� �����������. ����� ������� ��� �������� ���� �����, �� ������� ������ ���������� ��� ���.
� ����� ���� ��� ���������, Ҹ���� � �������, ������ �� ������� ����� ���������� ����� ��������������� ���������� ���������.
������ ����, �������� � ���, ������� a ������ �����, ���� ��� ���� �������� �� Ҹ����� ���������, � b ������ �����, ���� ��� ���� �������� �� ��������.
����� ��������� ���, ����� ������ ������� ����� c ������ �����. ���������, �������� �� ���.
������� ������
� ������ ������ �������� ����� �������� ��� ����� ����� a, b � c (1 <= a, b <= 100, 1 <= c <= 10 000) � ���������� ������ �����,
������� ��������� Ҹ���� � ������� ����������� �� ���� �������, � ���������� ������ �����, ������� ���������� ������� ����, ��������������.
�������� ������
���� ����� ����� ������� ����� c ������ �����, �� �������� �Yes� (��� �������), � ��������� ������ �������� �No� (��� �������).
�������
������� ������
4 6 15
�������� ������
No
������� ������
3 2 7
�������� ������
Yes
������� ������
6 11 6
�������� ������
Yes
����������
�� ������ ������� ����� ����� ��������� 1 ���� �� Ҹ����� ��������� � 2 ���� �� ��������, ����� ������� �� ������ �� ���� 1�3 + 2�2 = 7 ������ �����.

 */

using System;

namespace Edu003A
{
	class Program
	{
		public static void Main(string[] args)
		{
			string ss = Console.ReadLine ();
			string [] s = ss.Split (' ');
			int a = int.Parse (s [0]);
			int b = int.Parse (s [1]);
			int c = int.Parse (s [2]);

			bool ok = false;
			for ( int i=0; i < c; i++ )
				if ( a*i <= c && (c - a*i) % b == 0 )
				{
					ok = true;
					break;
				}

			if ( ok )
				Console.WriteLine ("Yes");
			else
				Console.WriteLine ("No");

//			Console.ReadKey(true);
		}
	}
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

namespace CodeForces
{
    public class CodeForces
    {
        static void Main(string[] args)
        {
            //var n = int.Parse(Console.ReadLine());
            var arr = GetArray();
            var a = arr[0];
            var b = arr[1];
            var c = arr[2];
            Console.WriteLine(Solve(a,b,c) ? "Yes" : "No");
        }

        public static void Tests()
        {
            //\
        }

        public static bool Solve(int a, int b, int c)
        {
            if ((c - a) % b == 0)
                return true;
            if ((c - b) % a == 0)
                return true;

            var m = c / a;
            for (var i = 1; i <= m; i++)
            {
                if ((c - (a * i)) % b == 0)
                    return true;
            }
            m = c / b;
            for (var i = 1; i <= m; i++)
            {
                if ((c - (b * i)) % a == 0)
                    return true;
            }

            return false;
        }

        static int[] GetArray()
        {

            return Array.ConvertAll(Console.ReadLine().Split(), Convert.ToInt32);
        }

    }
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

namespace CodeForces
{
    public class CodeForces
    {
        static void Main(string[] args)
        {
            //var n = int.Parse(Console.ReadLine());
            var arr = GetArray();
            var a = arr[0];
            var b = arr[1];
            var c = arr[2];
            Console.WriteLine(Solve(a,b,c) ? "Yes" : "No");
        }

        public static void Tests()
        {
            //\
        }

        public static bool Solve(int a, int b, int c)
        {

            if (c > a)
            {
                var m = c / a;

                for (var i = 1; i <= m; i++)
                {
                    if ((c - (a * i)) % b == 0)
                        return true;
                }
            }
            if (c > b)
            {
                var m = c / b;
                for (var i = 1; i <= m; i++)
                {
                    if ((c - (b * i)) % a == 0)
                        return true;
                }
            }
            return false;
        }

        static int[] GetArray()
        {

            return Array.ConvertAll(Console.ReadLine().Split(), Convert.ToInt32);
        }

    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            var data = Console.ReadLine().Split().Select(int.Parse).ToArray();
            var a = data[0];
            var b = data[1];
            var c = data[2];
            Console.WriteLine(c% Gcd(a,b) == 0? "Yes": "No");
        }

        static int Gcd(int a, int b)
        {
            if (b == 0)
                return a;
            return Gcd(b, a%b);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Threading;

namespace Codeforces
{
    class Program : IDisposable
    {
        private static readonly TextReader textReader = new StreamReader(Console.OpenStandardInput());
        private static readonly TextWriter textWriter = new StreamWriter(Console.OpenStandardOutput());

        void Solve()
        {
            var str = Console.ReadLine().Split(' ');
            var a = int.Parse(str[0]);
            var b = int.Parse(str[1]);
            var c = int.Parse(str[2]);
            for (int i = 1; i*b<=10000; ++i)
            {
                if ((c - i*b)%a == 0)
                {
                    Console.WriteLine("Yes");
                    return;
                }
            }
            Console.WriteLine("No");
            //Console.ReadLine();
        }

        static void Main(string[] args)
        {
            var p = new Program();
            p.Solve();
            p.Dispose();
        }

        #region Helpers

        private static int ReadInt()
        {
            return int.Parse(textReader.ReadLine());
        }

        private static long ReadLong()
        {
            return long.Parse(textReader.ReadLine());
        }

        private static int[] ReadIntArray()
        {
            return textReader.ReadLine().Split(' ').Select(int.Parse).ToArray();
        }
        #endregion

        public void Dispose()
        {
            textReader.Close();
            textWriter.Close();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Threading;

namespace Codeforces
{
    class Program : IDisposable
    {
        private static readonly TextReader textReader = new StreamReader(Console.OpenStandardInput());
        private static readonly TextWriter textWriter = new StreamWriter(Console.OpenStandardOutput());

        void Solve()
        {
            var str = Console.ReadLine().Split(' ');
            var a = int.Parse(str[0]);
            var b = int.Parse(str[1]);
            var c = int.Parse(str[2]);
            for (int i = 1; i<=1000000; ++i)
            {
                if ((c - i*b)%a == 0)
                {
                    Console.WriteLine("Yes");
                    return;
                }
            }
            Console.WriteLine("No");
            //Console.ReadLine();
        }

        static void Main(string[] args)
        {
            var p = new Program();
            p.Solve();
            p.Dispose();
        }

        #region Helpers

        private static int ReadInt()
        {
            return int.Parse(textReader.ReadLine());
        }

        private static long ReadLong()
        {
            return long.Parse(textReader.ReadLine());
        }

        private static int[] ReadIntArray()
        {
            return textReader.ReadLine().Split(' ').Select(int.Parse).ToArray();
        }
        #endregion

        public void Dispose()
        {
            textReader.Close();
            textWriter.Close();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Threading;

namespace Codeforces
{
    class Program : IDisposable
    {
        private static readonly TextReader textReader = new StreamReader(Console.OpenStandardInput());
        private static readonly TextWriter textWriter = new StreamWriter(Console.OpenStandardOutput());

        void Solve()
        {
            var str = Console.ReadLine().Split(' ');
            var a = int.Parse(str[0]);
            var b = int.Parse(str[1]);
            var c = int.Parse(str[2]);
            for (int i = 1; i*b<=10000; ++i)
            {
                if ((c - i * b) % a == 0 && (c - i * b) / a > 0)
                {
                    Console.WriteLine("Yes");
                    return;
                }
            }
            Console.WriteLine("No");
            //Console.ReadLine();
        }

        static void Main(string[] args)
        {
            var p = new Program();
            p.Solve();
            p.Dispose();
        }

        #region Helpers

        private static int ReadInt()
        {
            return int.Parse(textReader.ReadLine());
        }

        private static long ReadLong()
        {
            return long.Parse(textReader.ReadLine());
        }

        private static int[] ReadIntArray()
        {
            return textReader.ReadLine().Split(' ').Select(int.Parse).ToArray();
        }
        #endregion

        public void Dispose()
        {
            textReader.Close();
            textWriter.Close();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Threading;

namespace Codeforces
{
    class Program : IDisposable
    {
        private static readonly TextReader textReader = new StreamReader(Console.OpenStandardInput());
        private static readonly TextWriter textWriter = new StreamWriter(Console.OpenStandardOutput());

        void Solve()
        {
            var str = Console.ReadLine().Split(' ');
            var a = int.Parse(str[0]);
            var b = int.Parse(str[1]);
            var c = int.Parse(str[2]);
            for (int i = 0; i*b<=10000; ++i)
            {
                if ((c - i * b) % a == 0 && (c - i * b) / a > 0)
                {
                    Console.WriteLine("Yes");
                    return;
                }
            }
            Console.WriteLine("No");
            //Console.ReadLine();
        }

        static void Main(string[] args)
        {
            var p = new Program();
            p.Solve();
            p.Dispose();
        }

        #region Helpers

        private static int ReadInt()
        {
            return int.Parse(textReader.ReadLine());
        }

        private static long ReadLong()
        {
            return long.Parse(textReader.ReadLine());
        }

        private static int[] ReadIntArray()
        {
            return textReader.ReadLine().Split(' ').Select(int.Parse).ToArray();
        }
        #endregion

        public void Dispose()
        {
            textReader.Close();
            textWriter.Close();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ForCodeForces
{
    class Program
    {
        static void Main(string[] args)
        {
            string s = Console.ReadLine();
            string[] array = s.Split(' ');
            int[] numbers = new int[3];
            for (int i = 0; i < array.Length; i++)
                numbers[i] = int.Parse(array[i]);
            bool flag = false;

            for (int i = 0; i < (int) (numbers[2]/numbers[0]); i++)
            {
                for (int j = 0; j < (int) (numbers[2]/numbers[0]); j++)
                {
                    if (numbers[0]*i + numbers[1]*j == numbers[2])
                    {
                        flag = true;
                        break;
                    }
                }
            }
            Console.WriteLine(flag ? "Yes" : "No");
            Console.ReadLine();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ForCodeForces
{
    class Program
    {
        static void Main(string[] args)
        {
            string s = Console.ReadLine();
            string[] array = s.Split(' ');
            int[] numbers = new int[3];
            for (int i = 0; i < array.Length; i++)
                numbers[i] = int.Parse(array[i]);
            bool flag = false;

            for (int i = 0; i <= (int) (numbers[2]/numbers[0]); i++)
            {
                for (int j = 0; j <= (int) (numbers[2]/numbers[0]); j++)
                {
                    if (numbers[0]*i + numbers[1]*j == numbers[2])
                    {
                        flag = true;
                        break;
                    }
                }
            }
            Console.WriteLine(flag ? "Yes" : "No");
            Console.ReadLine();
        }
    }
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

namespace ConsoleApplication5
{
    class Program
    {
        static void Main(string[] args)
        {
            long first = MyConsoleInputStreamParser.GetLong, second = MyConsoleInputStreamParser.GetLong, all = MyConsoleInputStreamParser.GetLong;
            var answerFind = false;
            long i = 0;
            while (i * first <= all)
            {
                long g = 0;
                while (i * first + g * second < all)
                    g++;
                if (i * first + g * first == all)
                {
                    answerFind = true;
                    break;
                }
                i++;
            }
            //for (int i = 1; i < all / first; i++)
            //    for (int g = 1; g < all / second; g++)
            //    {
            //        var temp = i * first + g * second;
            //        if (temp == all)
            //        {
            //            answerFind = true;
            //            break;
            //        }
            //        if (temp > all)
            //            break;
            //    }
            if (answerFind)
                Console.WriteLine("Yes");
            else
                Console.WriteLine("No");
        }

        public static class MyConsoleInputStreamParser
        {
            private static TextReader reader = new StreamReader(Console.OpenStandardInput());
            private static Queue<string> currentLineStrings = new Queue<string>();

            public static string GetLine { get { return reader.ReadLine(); } }

            public static string GetString { get { while (currentLineStrings.Count == 0) currentLineStrings = new Queue<string>(GetStringArray); return currentLineStrings.Dequeue(); } }

            public static int GetInt { get { return int.Parse(GetString); } }

            public static long GetLong { get { return long.Parse(GetString); } }

            public static double GetDouble { get { return double.Parse(GetString, CultureInfo.InvariantCulture); } }

            public static char[] GetCharArray { get { return GetLine.ToCharArray(); } }

            public static string[] GetStringArray { get { return GetLine.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries); } }

            public static int[] GetIntArray { get { return GetStringArray.Select(int.Parse).ToArray(); } }

            public static long[] GetLongArray { get { return GetStringArray.Select(long.Parse).ToArray(); } }

            public static double[] GetDoubleArray { get { return GetStringArray.Select(s => double.Parse(s, CultureInfo.InvariantCulture)).ToArray(); } }

            public static char[][] ReturnCharMatrix(int numberOfRows) { char[][] matrix = new char[numberOfRows][]; for (int i = 0; i < numberOfRows; i++) matrix[i] = GetCharArray; return matrix; }

            public static string[][] ReturnStringMatrix(int numberOfRows) { string[][] matrix = new string[numberOfRows][]; for (int i = 0; i < numberOfRows; i++) matrix[i] = GetStringArray; return matrix; }

            public static int[][] ReturnIntMatrix(int numberOfRows) { int[][] matrix = new int[numberOfRows][]; for (int i = 0; i < numberOfRows; i++) matrix[i] = GetIntArray; return matrix; }

            public static long[][] ReturnLongMatrix(int numberOfRows) { long[][] matrix = new long[numberOfRows][]; for (int i = 0; i < numberOfRows; i++) matrix[i] = GetLongArray; return matrix; }

            public static double[][] ReturnDoubleMatrix(int numberOfRows) { double[][] matrix = new double[numberOfRows][]; for (int i = 0; i < numberOfRows; i++) matrix[i] = GetDoubleArray; return matrix; }
        }
    }
}

using System;
using System.Globalization;
using System.IO;
using System.Linq;

namespace CF317
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            var sr = new InputReader(Console.In);
            //var sr = new InputReader(new StreamReader("input.txt"));
            var task = new Task();
            using (var sw = Console.Out)
            {
                task.Solve(1, sr, sw);
                //Console.ReadKey();
            }
        }
    }

    internal class Task
    {
        public void Solve(int testNumber, InputReader sr, TextWriter sw)
        {
            var input = sr.ReadArray(Int32.Parse);
            var a = input[0];
            var b = input[1];
            var c = input[2];
            if (c%a == 0)
            {
                sw.WriteLine("Yes");
                return;
            }
            if (c%b == 0)
            {
                sw.WriteLine("Yes");
                return;
            }
            if (c%(a + b) == 0)
            {
                sw.WriteLine("Yes");
                return;
            }
            if (c < a && c < b)
            {
                sw.WriteLine("No");
                return;
            }
            var max = 10001;
            var dp = new bool[3, max];
            dp[0, 0] = true;
            for (var i = a; i < max; i+=a)
            {
                dp[0, i] = true;
            }
            for (var i = 0; i < max; i++)
            {
                if (i%b == 0)
                {
                    dp[1, i] = true;
                }
                else
                {
                    dp[1, i] = dp[0, i];
                }
            }
            for (var k = 0; k < max; k++)
            {
                if (k >= b || k >= a)
                {
                    dp[2, k] = dp[1, k];
                    if (k >= b)
                    {
                        dp[2, k] = dp[2, k] || dp[1, k - b];
                    }
                    if (k >= a)
                    {
                        dp[2, k] = dp[2, k] || dp[1, k - a];
                    }
                }
                else
                {
                    dp[2, k] = dp[1, k];
                }
            }
            sw.WriteLine(dp[2, c] ? "Yes" : "No");
        }
    }

    internal class InputReader : IDisposable
    {
        private bool isDispose;
        private readonly TextReader sr;

        public InputReader(TextReader stream)
        {
            sr = stream;
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        public string NextString()
        {
            var result = sr.ReadLine();
            return result;
        }

        public int NextInt32()
        {
            return Int32.Parse(NextString());
        }

        public long NextInt64()
        {
            return Int64.Parse(NextString());
        }

        public string[] NextSplitStrings()
        {
            return NextString()
                .Split(new[] {' '}, StringSplitOptions.RemoveEmptyEntries);
        }

        public T[] ReadArray<T>(Func<string, CultureInfo, T> func)
        {
            return NextSplitStrings()
                .Select(s => func(s, CultureInfo.InvariantCulture))
                .ToArray();
        }

        protected void Dispose(bool dispose)
        {
            if (!isDispose)
            {
                if (dispose)
                    sr.Close();
                isDispose = true;
            }
        }

        ~InputReader()
        {
            Dispose(false);
        }
    }
}

using System;
using System.Globalization;
using System.IO;
using System.Linq;

namespace CF317
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            var sr = new InputReader(Console.In);
            //var sr = new InputReader(new StreamReader("input.txt"));
            var task = new Task();
            using (var sw = Console.Out)
            {
                task.Solve(1, sr, sw);
                //Console.ReadKey();
            }
        }
    }

    internal class Task
    {
        public void Solve(int testNumber, InputReader sr, TextWriter sw)
        {
            var input = sr.ReadArray(Int32.Parse);
            var a = input[0];
            var b = input[1];
            var c = input[2];
            if (c%a == 0)
            {
                sw.WriteLine("Yes");
                return;
            }
            if (c%b == 0)
            {
                sw.WriteLine("Yes");
                return;
            }
            if (c%(a + b) == 0)
            {
                sw.WriteLine("Yes");
                return;
            }
            if (c < a && c < b)
            {
                sw.WriteLine("No");
                return;
            }
            var max = 10001;
            var dp = new bool[3, 10001];
            for (var i = a; i < max; i++)
            {
                dp[0, a] = true;
            }
            for (var i = 0; i < max; i++)
            {
                if (i%b == 0)
                {
                    dp[1, i] = true;
                }
                else
                {
                    dp[1, i] = dp[0, i];
                }
            }
            for (var k = 0; k < max; k++)
            {
                if (k >= b || k >= a)
                {
                    dp[2, k] = dp[1, k];
                    if (k >= b)
                    {
                        dp[2, k] = dp[2, k] || dp[1, k - b];
                    }
                    if (k >= a)
                    {
                        dp[2, k] = dp[2, k] || dp[1, k - a];
                    }
                }
                else
                {
                    dp[2, k] = dp[1, k];
                }
            }
            sw.WriteLine(dp[2, c] ? "Yes" : "No");
        }
    }

    internal class InputReader : IDisposable
    {
        private bool isDispose;
        private readonly TextReader sr;

        public InputReader(TextReader stream)
        {
            sr = stream;
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        public string NextString()
        {
            var result = sr.ReadLine();
            return result;
        }

        public int NextInt32()
        {
            return Int32.Parse(NextString());
        }

        public long NextInt64()
        {
            return Int64.Parse(NextString());
        }

        public string[] NextSplitStrings()
        {
            return NextString()
                .Split(new[] {' '}, StringSplitOptions.RemoveEmptyEntries);
        }

        public T[] ReadArray<T>(Func<string, CultureInfo, T> func)
        {
            return NextSplitStrings()
                .Select(s => func(s, CultureInfo.InvariantCulture))
                .ToArray();
        }

        protected void Dispose(bool dispose)
        {
            if (!isDispose)
            {
                if (dispose)
                    sr.Close();
                isDispose = true;
            }
        }

        ~InputReader()
        {
            Dispose(false);
        }
    }
}

using System;
using System.Globalization;
using System.IO;
using System.Linq;

namespace CF317
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            var sr = new InputReader(Console.In);
            //var sr = new InputReader(new StreamReader("input.txt"));
            var task = new Task();
            using (var sw = Console.Out)
            {
                task.Solve(1, sr, sw);
                //Console.ReadKey();
            }
        }
    }

    internal class Task
    {
        public void Solve(int testNumber, InputReader sr, TextWriter sw)
        {
            var input = sr.ReadArray(Int32.Parse);
            var a = input[0];
            var b = input[1];
            var c = input[2];
            if (c%a == 0)
            {
                sw.WriteLine("Yes");
                return;
            }
            if (c%b == 0)
            {
                sw.WriteLine("Yes");
                return;
            }
            if (c%(a + b) == 0)
            {
                sw.WriteLine("Yes");
                return;
            }
            if (c < a && c < b)
            {
                sw.WriteLine("No");
                return;
            }
            var max = 10001;
            var dp = new bool[3, max];
            dp[0, 0] = true;
            for (var i = a; i < max; i+=a)
            {
                dp[0, a] = true;
            }
            for (var i = 0; i < max; i++)
            {
                if (i%b == 0)
                {
                    dp[1, i] = true;
                }
                else
                {
                    dp[1, i] = dp[0, i];
                }
            }
            for (var k = 0; k < max; k++)
            {
                if (k >= b || k >= a)
                {
                    dp[2, k] = dp[1, k];
                    if (k >= b)
                    {
                        dp[2, k] = dp[2, k] || dp[1, k - b];
                    }
                    if (k >= a)
                    {
                        dp[2, k] = dp[2, k] || dp[1, k - a];
                    }
                }
                else
                {
                    dp[2, k] = dp[1, k];
                }
            }
            sw.WriteLine(dp[2, c] ? "Yes" : "No");
        }
    }

    internal class InputReader : IDisposable
    {
        private bool isDispose;
        private readonly TextReader sr;

        public InputReader(TextReader stream)
        {
            sr = stream;
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        public string NextString()
        {
            var result = sr.ReadLine();
            return result;
        }

        public int NextInt32()
        {
            return Int32.Parse(NextString());
        }

        public long NextInt64()
        {
            return Int64.Parse(NextString());
        }

        public string[] NextSplitStrings()
        {
            return NextString()
                .Split(new[] {' '}, StringSplitOptions.RemoveEmptyEntries);
        }

        public T[] ReadArray<T>(Func<string, CultureInfo, T> func)
        {
            return NextSplitStrings()
                .Select(s => func(s, CultureInfo.InvariantCulture))
                .ToArray();
        }

        protected void Dispose(bool dispose)
        {
            if (!isDispose)
            {
                if (dispose)
                    sr.Close();
                isDispose = true;
            }
        }

        ~InputReader()
        {
            Dispose(false);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            String[] numbersString = Console.ReadLine().Split(' ');
            int a = Convert.ToInt32(numbersString[0]);
            int b = Convert.ToInt32(numbersString[1]);
            int c = Convert.ToInt32(numbersString[2]);
            bool temp = false;
            for (int i = 1; i <= a; i++)
            {
                for (int j = 1; j <= b; j++)
                {
                    if (temp == false)
                    {
                        if ((i * a + j * b) == c)
                        {
                            temp = true;
                        }
                    }
                }
            }
            if (temp == true)
                Console.WriteLine("Yes");
            else
                Console.WriteLine("No");
            Console.ReadLine();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            String[] numbersString = Console.ReadLine().Split(' ');
            int a = Convert.ToInt32(numbersString[0]);
            int b = Convert.ToInt32(numbersString[1]);
            int c = Convert.ToInt32(numbersString[2]);
            bool temp = false;
            for (int i = 0; i <= a; i++)
            {
                for (int j = 0; j <= b; j++)
                {
                    if (temp == false)
                    {
                        if ((i * a + j * b) == c)
                        {
                            temp = true;
                        }
                    }
                }
            }
            if (temp == true)
                Console.WriteLine("Yes");
            else
                Console.WriteLine("No");
            Console.ReadLine();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication29
{

    class Program
    {

        static void Main(string[] args)
        {
            args = Console.ReadLine().Split();
            int a = int.Parse(args[0]);
            int b = int.Parse(args[1]);
            int c = int.Parse(args[2]);
            bool sta = false;
            if (c%a==0 || c%b==0)
            {
                Console.WriteLine("Yes");
            }
            else
            {
                int min = Math.Min(a,b);
                c -= (a + b);
                for (; c>=0;)
                {

                    if (min==a)
                    {
                        c -= a;
                        if (c==0)
                        {
                            sta = true;
                            break;
                        }

                    }
                    else
                    {
                        c -= b;
                        if (c == 0)
                        {
                            sta = true;
                            break;
                        }
                    }
                }
                if (sta)
                {
                    Console.WriteLine("Yes");
                }
                else
                {
                    Console.WriteLine("No");
                }
            }
        }
    }
}

using System;
using System.Linq;

namespace CodeForces
{
	class MainClass
	{
		public static void Main(string[] args)
		{
			string line1 = Console.ReadLine();
			string[] split = line1.Split(new Char[] { ' ', ',', '.', ':', '\t' });
			int a = Int32.Parse(split[0]);
			int b = Int32.Parse(split[1]);
			int c = Int32.Parse(split[2]);
			int gun1 = c % a;
			gun1 = gun1 % b;
			int gun2 = c % b;
			gun2 = gun2 % a;
			if (gun1 == 0 || gun2 == 0)
			{
				Console.WriteLine("YES");
			}
			else
			{
				Console.WriteLine("NO");
			}

		}

	}

}

using System;
using System.Linq;

namespace CodeForces
{
	class MainClass
	{
		public static void Main(string[] args)
		{
			string line1 = Console.ReadLine();
			string[] split = line1.Split(new Char[] { ' ', ',', '.', ':', '\t' });
			int a = Int32.Parse(split[0]);
			int b = Int32.Parse(split[1]);
			int c = Int32.Parse(split[2]);
			int gun1 = c;
			bool solved = false;
			while (gun1 > 0)
			{
				gun1 -= a;
				if (gun1 % b == 0)
				{
					solved = true;
				}
			}
			int gun2 = c;
			while (gun2 > 0)
			{
				gun2 -= b;
				if (gun2 % a == 0)
				{
					solved = true;
				}
			}
			if (solved)
			{
				Console.WriteLine("Yes");
			}
			else
			{
				Console.WriteLine("No");
			}

		}

	}

}

using System;
using System.Linq;

namespace CodeForces
{
	class MainClass
	{
		public static void Main(string[] args)
		{
			string line1 = Console.ReadLine();
			string[] split = line1.Split(new Char[] { ' ', ',', '.', ':', '\t' });
			int a = Int32.Parse(split[0]);
			int b = Int32.Parse(split[1]);
			int c = Int32.Parse(split[2]);
			int gun1 = c;
			bool solved = false;
			while (gun1 > 0)
			{
				gun1 -= a;
				if (gun1 % b == 0)
				{
					solved = true;
				}
			}
			int gun2 = c;
			while (gun2 > 0)
			{
				gun2 -= b;
				if (gun2 % a == 0)
				{
					solved = true;
				}
			}
			if (solved)
			{
				Console.WriteLine("YES");
			}
			else
			{
				Console.WriteLine("NO");
			}

		}

	}

}

using System;

namespace A633{
	class Program{
		static void Main(string[] args){
            int[] abc = Array.ConvertAll(Console.ReadLine().Split(' '), int.Parse);

            // a * x + b * y = c
            int ebonyShots = 0;
            int ivoryShots = 0;
            if(abc[2] % abc[0] == 0 || abc[2] % abc[1] == 0)
            {
                Console.WriteLine("Yes");
                return;
            }

            while (ebonyShots * abc[0] + ivoryShots * abc[1] < abc[2])
            {
                while (ebonyShots * abc[0] + ivoryShots * abc[1] < abc[2])
                {
                    ivoryShots++;
                }
                ebonyShots++;
                if(ebonyShots * abc[0] + ivoryShots * abc[1] == abc[2])
                {
                    Console.WriteLine("Yes");
                    return;
                } else
                {
                    ivoryShots = 0;
                }
            }
            Console.WriteLine("No");
		}
	}
}

using System;

namespace A633{
	class Program{
		static void Main(string[] args){
            int[] abc = Array.ConvertAll(Console.ReadLine().Split(' '), int.Parse);

            // a * x + b * y = c
            int ebonyShots = 0;
            int ivoryShots = 0;
            while (ebonyShots * abc[0] + ivoryShots * abc[1] < abc[2])
            {
                ebonyShots++;
                while (ebonyShots * abc[0] + ivoryShots * abc[1] < abc[2])
                {
                    ivoryShots++;
                }
                if(ebonyShots * abc[0] + ivoryShots * abc[1] == abc[2])
                {
                    Console.WriteLine("Yes");
                    return;
                } else
                {
                    ivoryShots = 0;
                }
            }
            Console.WriteLine("No");
		}
	}
}

using System;
using System.Collections.Generic;
using System.Collections;
using System.Linq;
using System.Numerics;

namespace contest
{

    class contest
    {

        static void Main(string[] args)
        {

            //int n = int.Parse(Console.ReadLine());
            //var input = Console.ReadLine().Split().Select(int.Parse).ToArray();

            //var num = Console.ReadLine().Split().Select(int.Parse).ToArray();

            var num = Console.ReadLine().Split().Select(int.Parse).ToArray();
            int a = num[0];
            int b = num[1];
            int c = num[2];

            int tmp = c;
            bool pos = false;
            if (c == a || c == b) pos = true;
            while(tmp>=b)
            {
                if (divisible(tmp, a))
                {
                    pos = true;
                    break;
                }
                else tmp -= b;
            }
            if (!pos)
            {
                tmp = c;
                while (tmp >= a)
                {
                    if (divisible(tmp, b))
                    {
                        pos = true;
                        break;
                    }
                    else tmp -= a;
                }
            }
            Console.WriteLine((pos) ?"Yes" : "No");

            //Console.WriteLine();

            //Console.Read();

        }

        public static bool divisible(int c, int d)
        {
            return c % d == 0 ? true : false;
        }

    }

}