Problem: A line on the plane is described by an equation Ax + By + C = 0. You are to find any point on this line, whose coordinates are integer numbers from  - 5·1018 to 5·1018 inclusive, or to find out that such points do not exist.

Input

The first line contains three integers A, B and C ( - 2·109 ≤ A, B, C ≤ 2·109) — corresponding coefficients of the line equation. It is guaranteed that A2 + B2 > 0.

Output

If the required point exists, output its coordinates, otherwise output -1.

Examples

Input

2 5 3


Output

6 -3

Solution (in JAVA):

Solution:

import static java.util.Arrays.*;
import static java.lang.Math.*;
import java.util.*;
import java.io.*;

import static java.math.BigInteger.*;
import java.math.*;

public class Main implements Runnable
{
	public static void main(String [] args) throws IOException
	{
		new Thread(null, new Main(), "", 1 << 20).start();
	}
	
	public void run() 
	{
		try
		{
			solve();
		}
		catch(Exception ex)
		{
			ex.printStackTrace();
		}
	}
	
	String file = "input";
	BufferedReader input;

	void solve() throws IOException
	{
		//input = new BufferedReader(new FileReader(file + ".in"));
	    input = new BufferedReader(new InputStreamReader(System.in));
	    
	   	StringTokenizer st = tokens();
	   	int a = nextInt(st), n = nextInt(st), b = nextInt(st);
	   	if(n == 0)
	   	{
	   		if(b % a == 0)
	   		{
	   			System.out.println((-b / a) + " " + 0);
	   		}
	   		else
	   			System.out.println(-1);
	   		return;
	   	}
	   	n = -n; b = -b;
	   	long[] DD = egcd(a, n);
	   	long d = DD[0], x = DD[1], y = DD[2];
	   	
	   	/*
	   	long xx = 1L << 40;
	   	System.out.println(xx + " " + (xx * xx));
	   	//System.out.println((5 % 3) + " " + (5 % -3));
	   	BigInteger B = valueOf(b);
	   	BigInteger D = valueOf(d);
	   	BigInteger X = valueOf(x);
	   	BigInteger Y = valueOf(y);
	 	if(n < 0) n = -n;
	   	BigInteger N = valueOf(n);
	   	BigInteger A = valueOf(a);
	   	BigInteger min = valueOf(-5000000000000000000L);
	   	BigInteger max = valueOf(5000000000000000000L);
	   	*/
	   	if(b % d == 0)
	   	{
	   		long x0 = (b / d * x) % n;
	   		long y0 = (a * x0 - b) / n;
	   		System.out.println(x0 + " " + y0);
	   		//BigInteger X0 = B.divide(D).multiply(X).mod(N);
	   		//BigInteger Y0 = A.multiply(X0).subtract(B).divide(N).multiply(valueOf(-1));
	   		//if(X0.compareTo(min) >= 0 && X0.compareTo(max) <= 0 && Y0.compareTo(min) >= 0 && Y0.compareTo(max) <= 0)
	   		//	System.out.println(X0 + " " + Y0);
	   		//else
	   		//	System.out.println(-1);
	   	}
	   	else
	   	{
	   		System.out.println(-1);
	   	}
	  
	}
	public long [] egcd(long a, long b)
	{
		if(b == 0)
			return new long [] {a, 1, 0};
		long[] d = egcd(b, a % b);
		
		return new long[] {d[0], d[2], d[1] - a / b * d[2]};
	}


	StringTokenizer tokens() throws IOException
	{
		return new StringTokenizer(input.readLine());
	}
	
	String next(StringTokenizer st)
	{
		return st.nextToken();
	}
	
	int nextInt() throws IOException
	{
		return Integer.parseInt(input.readLine());
	}
	
	int nextInt(StringTokenizer st)
	{
		return Integer.parseInt(st.nextToken());
	}
	
	double nextDouble() throws IOException
	{
		return Double.parseDouble(input.readLine());
	}
	
	double nextDouble(StringTokenizer st)
	{
		return Double.parseDouble(st.nextToken());
	}
	
	void print(Object... o)
	{
		System.out.println(deepToString(o));
	}
}