Problem: 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.

Solution (in JAVA):

Solution:
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.concurrent.ExecutionException;

import javax.management.Query;
import javax.swing.plaf.nimbus.NimbusLookAndFeel;
import javax.swing.text.DefaultEditorKit.PasteAction;
import javax.xml.bind.ParseConversionEvent;

import java.util.PriorityQueue;
import java.util.Set;
import java.util.Stack;
import java.util.StringTokenizer;
import static java.lang.Integer.parseInt;
import static java.lang.Long.parseLong;
import static java.lang.Double.parseDouble;



public class Solution { 
 	static  int mod=1000000007;
 	static int count=1;
 	
	public static void main(String[] args) throws IOException, InterruptedException {
		PrintWriter out=new PrintWriter(System.out); 
		BufferedReader br=new  BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st;
	    double n=parseInt(br.readLine());
	    double a=parseInt(br.readLine());
	    double b=parseInt(br.readLine());
	    double x=0;
	    double y=0;
	    boolean  sol=false;
	    while(x * a <=n){
	    	
	    	double k=n - x*a;
	    	//out.println(k);
	    	if((int)(k/b) == k/b){
	    		sol= true;
	    		y=k/b;
	    		break;
	    	}
	    	++x;
	    	
	    }
	    if(sol){
	    	out.println("YES");
	    	out.print((int)x+" "+(int)y);
	    }else out.println("NO");
		 out.close();
		
	
	
	
	
	
}
	static int fraction(int a, int b, int c){
		for(int i=0;i < 1000;++i){
			a*=10;
			if(a/b == c) return i+1;
			a=a%b;
	
		}
		return -1;
	}
	static class E{
		int x;
		int y;
		public E(int x, int y){
			this.x=x;
			this.y=y;
		}
	}
	static void color(LinkedList<Integer>[] list,int[] color,  int parent){
		
		for(int i=0; i < list[parent].size(); ++i){
			if(color[parent] != color[list[parent].get(i)]){
				++count;
				//System.out.println(parent+":             "+list[parent].get(i));
			
			}
			try{
				color(list, color, list[parent].get(i));
			}catch(Exception e){
				System.out.println(parent+"    "+list[parent].get(i)+"   "+e.getMessage());
				
			}
			
			
		}	
		/*for(int i=0 ; i < list[child].size();++i){
			if(color[child] != color[list[child].get(i)]){
				System.out.println(child+":             "+list[child].get(i));
					color(list, color, list[child].get(i));
			}
		}*/
	}
	static boolean answer(int n){
		if(n < 0) return false;
		else if(n == 0) return true;
		return (answer(n - 3) || answer(n - 7));
		
	}
	static int[][] createMatrix(int n, int m){
		int[][] matrix=new int[n][m];
		for(int i=0 ; i < n   ;++i){
			for(int k = 0; k < m;++k){
				if(k==0 || k==1) matrix[i][k]=i*m + k+1;
				else if (i%2 == 0){
					int inter=matrix[i][k-2];
					matrix[i][k] = inter;
					matrix[i][k-2]=i*m + k+1;
				}else{
					matrix[i][k]=i*m + k+1;
				}
			}
		}
		
		
		for(int i = 1; i < n; i+=2){
			for(int k=0; k < m; k+=2){
				int inter=matrix[i][k];
				matrix[i][k]=matrix[i-1][k];
				matrix[i-1][k]=inter;
			}
		}
		return matrix;
	}
	static boolean nim_game(int n){
		int[] win_pos=new int[]{2, 3, 5, 4};
		if(n > 0){
			for(int x: win_pos){
				if(x == n) return true;
			}
			if(n == 1) return false;
			if(!nim_game(n - 5)|| !nim_game(n - 3)|| !nim_game(n - 2)) return true;
		}
		return false;
	}
	static int xor_range(int n){
		if(n == 0) return 0;
		int r= n% 4;
		if(r == 0) return n; 
		if(r == 1) return 1;
		if(r == 2) return n+1;
		return 0;
	}
	static void sol(int[] arr, int index, int time, int k, HashMap<Integer, Integer> map, int sum){
		if( time == k+1){ 
				if(map.containsKey(sum)) map.put(sum, map.get(sum) + 1);
				else map.put(sum, 1);
		}
		
		if(time <= k){
			for(int i=index ; i  < arr.length; ++i){
				sol(arr, i + 1 , time + 1 , k, map, sum + arr[i]);
			}
		}
	}
	
	static int combinaison(double n, double k){//c(n, k)= (k+1)/(n-k)
		double res= 1;
		for(int i= 1; i<=k; ++i){
			res *= (n-i+1)/(i);
		}
		return (int)res;
	}
	static int countmin(int a, int b, int c){
		//Given a sequence of three binary sequences A, B and C of N bits. Count the minimum bits
		//required to flip in A and B such that XOR of A and B is equal to C
		int res= a ^ b ^ c;
		int count=0;
		while(res != 0){
			++count;
			res&=res - 1;
		}
		return count;
	}
	static int countval(int n){//Given a positive integer n, find count of positive integers i such that 0 <= i <= n and n+i = n^i
		int count=0;
		while(n != 0){
			if((n & 1) == 0) ++count;
		}
		return 1<<count;
	}
	static int firstright(int x){
		
		int y=1;
		int pos=1;
		while((x&y) == 0){
			pos++;
			y<<=1;
		}
		return pos;
	}
	
	static int atob(int a, int b){
		int c= a^b;
		int count=0;
		while(c != 0){
			c&=(c-1);
			++count;
		}
		return count;
	}
	  
	
	static int setBits(int x){
		int count=0;
		if(x == 0) return 0;
		while(x != 0){
			if(x % 2 == 1){
				--x;
				++count;
			}
			x/=2;
			
		}
		return count;
	}
	static boolean isPower4(long x){
			if((x & (x-1)) != 0) return false;
			int count=0;
			while(x != 1){
				x>>=1;
				++count;
			}
			
			if(count % 2 == 0) return true;
			return false;
	
	}
	
	
	
	static long addOne(long x){// add one using bit manipulation
	    long y = 1; 
		while((x & y) != 0){
			x ^= y;
			y<<=1;
		}
		
		return x ^ y;
	}
	
	static int compute_xor_range(int n){// compute xor from 1 to n
		int r= n % 4;
		if(r== 0) return n;
		else if(r== 1) return 1;
		else if(r== 2) return n+1;
		else return 0;
				
	}
	
	static long number_combinaisons(long n){//n cardinal of set 
		//fonction return number of combinaisons
		return (1 << n) ;
	}
	
	static boolean isPoweroftwo(long x){
		//check a number is power of two 
		//we use x & (x-1) to eliminate the first set bit
		
		return (x!=0 && (x & (x-1)) == 0)?true:false;
	}
	
	static long findxor(long[] Set,long n){// this function find xor of xor's of all subsets
		//n is length of set array
		if(n >1 ) return 0;
		else return Set[0];
	}
	// pour generer un nombre entier a partir de binaire int a=0b111;
	
	static long MSB(long n){// most significant bit
		while((n&(n-1)) != 0){
			n &= n-1;
		}
		return n;
	}
	
	static long LSB(long n){
	      if(n == 0) return 0;
	      return n-(n & (n-1));
	}
	
	
	 
	
		
}