Dante is engaged in a fight with "The Savior". Before he can fight it with his sword, he needs to break its shields. He has two guns, Ebony and Ivory, each of them is able to perform any non-negative number of shots.For every bullet that hits the shield, Ebony deals a units of damage while Ivory deals b units of damage. In order to break the shield Dante has to deal exactly c units of damage. Find out if this is possible.

The first line of the input contains three integers a, b, c (1 ≤ a, b ≤ 100, 1 ≤ c ≤ 10 000) — the number of units of damage dealt by Ebony gun and Ivory gun, and the total number of damage required to break the shield, respectively.

Print "Yes" (without quotes) if Dante can deal exactly c damage to the shield and "No" (without quotes) otherwise.

NoteIn the second sample, Dante can fire 1 bullet from Ebony and 2 from Ivory to deal exactly 1·3 + 2·2 = 7 damage. In the third sample, Dante can fire 1 bullet from ebony and no bullets from ivory to do 1·6 + 0·11 = 6 damage.

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;

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;

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;

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;
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));}
}

/*
 * 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;
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;
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.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;
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.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;
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;
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.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;

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;
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;

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.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.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;
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
{
	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;
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 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;

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;
        }

    }

}