Vasya has n burles. One bottle of Ber-Cola costs a burles and one Bars bar costs b burles. He can buy any non-negative integer number of bottles of Ber-Cola and any non-negative integer number of Bars bars.

Find out if it's possible to buy some amount of bottles of Ber-Cola and Bars bars and spend exactly n burles.

In other words, you should find two non-negative integers x and y such that Vasya can buy x bottles of Ber-Cola and y Bars bars and x·a + y·b = n or tell that it's impossible.


-----Input-----

First line contains single integer n (1 ≤ n ≤ 10 000 000) — amount of money, that Vasya has.

Second line contains single integer a (1 ≤ a ≤ 10 000 000) — cost of one bottle of Ber-Cola.

Third line contains single integer b (1 ≤ b ≤ 10 000 000) — cost of one Bars bar.


-----Output-----

If Vasya can't buy Bars and Ber-Cola in such a way to spend exactly n burles print «NO» (without quotes).

Otherwise in first line print «YES» (without quotes). In second line print two non-negative integers x and y — number of bottles of Ber-Cola and number of Bars bars Vasya should buy in order to spend exactly n burles, i.e. x·a + y·b = n. If there are multiple answers print any of them.

Any of numbers x and y can be equal 0.


-----Examples-----
Input
7
2
3

Output
YES
2 1

Input
100
25
10

Output
YES
0 10

Input
15
4
8

Output
NO

Input
9960594
2551
2557

Output
YES
1951 1949



-----Note-----

In first example Vasya can buy two bottles of Ber-Cola and one Bars bar. He will spend exactly 2·2 + 1·3 = 7 burles.

In second example Vasya can spend exactly n burles multiple ways:   buy two bottles of Ber-Cola and five Bars bars;  buy four bottles of Ber-Cola and don't buy Bars bars;  don't buy Ber-Cola and buy 10 Bars bars. 

In third example it's impossible to but Ber-Cola and Bars bars in order to spend exactly n burles.

Difficulty: EASY

Solutions:
import bisect

def list_output(s):
	print(' '.join(map(str, s)))

def list_input(s='int'):
	if s == 'int':
		return list(map(int, input().split()))
	elif s == 'float':
		return list(map(float, input().split()))
	return list(map(str, input().split()))
n = int(input())
a = int(input())
b = int(input())
for x in range(n + 1):
	t = n - x * a
	if t >= 0 and t % b == 0:
		y = t // b
		print('YES')
		print(' '.join(map(str, [x, y])))
		exit(0)
print('NO')


(n, x, y) = (int(input()), int(input()), int(input()))
f = 0
for i in range(n // x + 1):
	s = n - i * x
	if s % y == 0:
		f = 1
		l = [i, s // y]
		break
if f == 0:
	print('NO')
else:
	print('YES')
	print(*l)


import math
n = int(input())
a = int(input())
b = int(input())
g = math.gcd(a, b)
if n % g != 0:
	print('NO')
else:
	x = 0
	while a * x <= n:
		if (n - a * x) % b == 0:
			print('YES')
			print(x, (n - a * x) // b)
			break
		x += 1
	else:
		print('NO')


import math

def solve():
	n = int(input())
	a = int(input())
	b = int(input())
	if n % 2 != 0 and a % 2 == 0 and (b % 2 == 0):
		print('NO')
		return
	else:
		for x in range(10000001):
			k = n - a * x
			if k >= 0 and k % b == 0:
				print('YES')
				print(x, k // b)
				return
			if k < 0:
				print('NO')
				return
	print('NO')
	return
for _ in range(1):
	solve()


def egcd(a, b):
	(x, y, u, v) = (0, 1, 1, 0)
	while a != 0:
		(q, r) = (b // a, b % a)
		(m, n) = (x - u * q, y - v * q)
		(b, a, x, y, u, v) = (a, r, u, v, m, n)
	gcd = b
	return (gcd, x, y)
import math
n = int(input())
a = int(input())
b = int(input())
(gcd, x, y) = egcd(a, b)
status = 0
if n % gcd != 0:
	print('NO')
else:
	multiply = n / gcd
	x1 = int(multiply * x)
	y1 = int(multiply * y)
	d1 = b / gcd
	d2 = a / gcd
	rangemin = int(math.ceil(-x1 / d1))
	rangemax = int(y1 // d2)
	if rangemin > rangemax:
		print('NO')
	else:
		m = rangemin
		while m <= rangemax:
			solx = x1 + m * d1
			soly = y1 - m * d2
			if solx >= 0 and soly >= 0:
				print('YES')
				status = 1
				print(str(int(solx)) + ' ' + str(int(soly)))
				break
			m = m + 1
		if status == 0:
			print('NO')


n = int(input())
a = int(input())
b = int(input())
flags = False
for i in range(n // a + 1):
	if n - i * a >= 0 and (n - i * a) % b == 0:
		print('YES')
		print(i, (n - i * a) // b)
		flags = True
		break
if not flags:
	print('NO')


n = int(input())
a = int(input())
b = int(input())
p = n // a
t = 0
for i in range(p + 1):
	if (n - i * a) % b == 0:
		t += 1
		(r, q) = (i, (n - i * a) // b)
		break
if t == 0:
	print('NO')
else:
	print('YES')
	print(r, q)


n = int(input())
a = int(input())
b = int(input())
bul = 0
for x in range(n // a + 1):
	if (n - x * a) % b == 0:
		print('YES')
		print(str(x) + ' ' + str((n - x * a) // b))
		bul = 1
		break
if bul == 0:
	print('NO')


def mp():
	return map(int, input().split())

def it():
	return int(input())
n = it()
a = it()
b = it()
(x, y) = (0, 0)
while n % b != 0 and n >= 0:
	n -= a
	x += 1
if n < 0:
	print('NO')
else:
	print('YES')
	print(x, n // b)


n = int(input())
a = int(input())
b = int(input())
for i in range(10 ** 7 + 4):
	x = a * i
	if n - x >= 0:
		d = n - x
		if d % b == 0:
			print('YES')
			print(i, d // b)
			exit()
	else:
		break
print('NO')


class CodeforcesTask898BSolution:

	def __init__(self):
		self.result = ''
		self.n = 0
		self.a = 0
		self.b = 0

	def read_input(self):
		self.n = int(input())
		self.a = int(input())
		self.b = int(input())

	def process_task(self):
		self.result = 'NO'
		for x in range(10000000):
			if x * self.a > self.n:
				break
			if not (self.n - self.a * x) % self.b:
				y = (self.n - self.a * x) // self.b
				self.result = 'YES\n{0} {1}'.format(x, y)
				break

	def get_result(self):
		return self.result
Solution = CodeforcesTask898BSolution()
Solution.read_input()
Solution.process_task()
print(Solution.get_result())


def read():
	return [int(v) for v in input().split()]

def main():
	n = read()[0]
	a = read()[0]
	b = read()[0]
	for x in range(0, n // a + 2):
		y = int((n - a * x) / b)
		if y >= 0 and a * x + b * y == n:
			print('YES\n{} {}'.format(x, y))
			return
	print('NO')
main()


n = int(input())
a = int(input())
b = int(input())
x = 0
flag = 0
while x <= n:
	if (n - x) % b == 0:
		print('YES')
		print(x // a, (n - x) // b)
		flag = 1
		break
	else:
		x += a
if flag == 0:
	print('NO')


import math
n = int(input())
a = int(input())
b = int(input())
MAXVAL = 10000000
x = 0
while a * x <= n:
	if (n - x * a) % b == 0:
		print('YES')
		print(x, (n - x * a) // b)
		return
	x += 1
print('NO')


(n, a, b) = [int(input()) for _ in [0] * 3]
for i in range(n + 2):
	if i * a > n:
		break
	if (n - i * a) % b < 1:
		print(f'YES\n{i} {(n - i * a) // b}')
		break
if i * a > n:
	print('NO')


n = int(input())
x = int(input())
y = int(input())
c = 0
while n >= 0 and n % y != 0:
	n = n - x
	c += 1
if n >= 0:
	print('YES')
	print(c, n // y)
else:
	print('NO')


from __future__ import division, print_function
import os
import sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
	from __builtin__ import xrange as range
	from future_builtins import ascii, filter, hex, map, oct, zip
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
import collections, itertools, statistics, math
from collections import *
from itertools import *
from statistics import *
from math import *
mod = int(1000000000.0 + 7)
imin = -2147483648
imax = 2147483647
true = True
false = False
none = None
inp = lambda : input()
I = lambda : int(inp())
M = lambda : map(int, inp().split())
L = lambda : list(M())
Yes = lambda : print('Yes')
No = lambda : print('No')
YES = lambda : print('YES')
NO = lambda : print('NO')

def IO():
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')

def true_yes(statement):
	return YES() if statement else NO()

def kabraji_ka_totka():
	n = I()
	a = I()
	b = I()
	count = 0
	while n >= 0 and n % b != 0:
		n -= a
		count += 1
	result = ['YES\n' + str(count), n // b]
	NO = ['NO']
	print(*(result if n >= 0 else NO))
kabraji_ka_totka()


import sys, os, time
from math import log, gcd
mod = 1000000007
mod1 = 998244353

def intinp():
	return int(sys.stdin.readline())

def strinp():
	return sys.stdin.readline()

def arrinp():
	return list(map(int, sys.stdin.readline().strip().split()))

def mulinp():
	return map(int, sys.stdin.readline().strip().split())

def flush():
	return sys.stdout.flush()

def power_two(x):
	return 1 << x

def lcm(a, b):
	return a * b // gcd(a, b)

def power(a, n):
	res = 1
	while n:
		if n & 1:
			res = res % mod * a % mod % mod
			n -= 1
		else:
			a = a % mod * a % mod % mod
			n = n // 2
	return res

def isnotsubseq(s1, s2):
	j = 0
	(n, m) = (len(s1), len(s2))
	for i in range(0, m):
		if s1[j] == s2[i]:
			j += 1
		if j == n:
			return False
	return True

def variable(n, a, b):
	i = 0
	while i * a <= n:
		if (n - i * a) % b == 0:
			return (i, (n - i * a) // b)
		i += 1
	return (None, None)

def sol():
	n = intinp()
	a = intinp()
	b = intinp()
	if n % gcd(a, b) != 0:
		print('NO')
		return
	(x, y) = variable(n, a, b)
	if x == None or y == None:
		print('NO')
		return
	print('YES')
	print(x, y)

def main():
	tc = 1
	while tc:
		sol()
		tc -= 1
main()


import sys
import collections
from collections import Counter
import itertools
import math
import timeit

def sieve(n):
	if n < 2:
		return list()
	prime = [True for _ in range(n + 1)]
	p = 3
	while p * p <= n:
		if prime[p]:
			for i in range(p * 2, n + 1, p):
				prime[i] = False
		p += 2
	r = [2]
	for p in range(3, n + 1, 2):
		if prime[p]:
			r.append(p)
	return r

def divs(n, start=1):
	divisors = []
	for i in range(start, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n / i == i:
				divisors.append(i)
			else:
				divisors.extend([i, n // i])
	return divisors

def divn(n, primes):
	divs_number = 1
	for i in primes:
		if n == 1:
			return divs_number
		t = 1
		while n % i == 0:
			t += 1
			n //= i
		divs_number *= t

def flin(d, x, default=-1):
	left = right = -1
	for i in range(len(d)):
		if d[i] == x:
			if left == -1:
				left = i
			right = i
	if left == -1:
		return (default, default)
	else:
		return (left, right)

def ceil(n, k):
	return n // k + (n % k != 0)

def ii():
	return int(input())

def mi():
	return map(int, input().split())

def li():
	return list(map(int, input().split()))

def lcm(a, b):
	return abs(a * b) // math.gcd(a, b)

def prr(a, sep=' '):
	print(sep.join(map(str, a)))

def dd():
	return collections.defaultdict(int)

def ddl():
	return collections.defaultdict(list)
n = ii()
a = ii()
b = ii()
x = 0
while n - x * a >= 0:
	if not (n - x * a) % b:
		print('YES')
		exit(print(x, (n - x * a) // b))
	x += 1
print('NO')


n = int(input())
a = int(input())
b = int(input())
i = 0
while True:
	if n - a * i < 0:
		print('NO')
		exit()
	elif (n - a * i) % b == 0:
		print('YES')
		print(i, (n - a * i) // b)
		exit()
	i += 1


n = int(input())
x = int(input())
y = int(input())
wins = 0
i = 0
while n >= x * i:
	if (n - x * i) % y == 0:
		wins = 1
		break
	i += 1
if wins == 1:
	print('YES')
	print(i, (n - x * i) // y)
else:
	print('NO')


def main():
	N = int(input())
	a = int(input())
	b = int(input())
	for i in range(0, N // a + 1):
		if (N - i * a) % b == 0 and N - i * a > -1:
			print('YES')
			print(i, (N - i * a) // b)
			return
	print('NO')
main()