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:
//package CodeForces;

import java.io.*;
import java.util.*;

public class Main implements Runnable {
    private void solve() throws IOException {
        int a = nextInt(), b = nextInt(), c = nextInt();
        long[] v = __solve (a, b, -c);
        if (v[0] == Long.MAX_VALUE) out.println (-1);
        else out.println (v[0] + " " + v[1]);
    }

    //My library functions
    //-------------------------------

    //checks if n is prime
    public boolean isPrime (int n) {
        if ((n <= 1) || ((n != 2) && (n % 2 == 0))) return false;
        if (n == 2) return true;
        for (int i = 3; i <= Math.round(Math.sqrt(n)); i += 2) {
            if (n % i == 0) return false;
        }
        return true;
    }

    //finds all primes in [1..n]
    public boolean[] sieve (int n) {
        boolean[] prime = new boolean[n+1];
        Arrays.fill(prime, true);
        prime[0] = prime[1] = false;
        for (int i = 2; i <= Math.round(Math.sqrt(n)); i++) {
            if (prime[i]) {
                for (int k = i*i; k <= n; k += i) {
                    prime[k] = false;
                }
            }
        }
        return prime;
    }

    //the Greatest Common Divisor
    public int gcd (int a, int b) {
        if (b == 0) return a;
        else return gcd (b, a % b);
    }

    //the Lowest Common Multiple
    public int lcm (int a, int b) {
        return a / gcd (a, b) * b;
    }

    //Euler function - the number of integers in [1..n] which are coprime with n
    //uses factorization
    public int phi (int n) {
        int res = n;
        for (int i = 2; i * i <= n; i++) {
            if (n % i == 0) {
                while (n % i == 0) {
                    n /= i;
                }
                res -= res / i;
            }
        }
        if (n > 1) res -= res / n;
        return res;
    }

    //binary powering for integers
    public long binPow (long n, int p) {
        if (p == 0) return 1L;
        if (p % 2 == 1) return n * binPow (n, p - 1);
        long tmp = binPow (n, p >> 1);
        return tmp * tmp;
    }

    //advanced GCD - finds such x and y that a*x + b*y == gcd (a, b)
    //returns int[] where res[0] is x and res[1] is y
    public int adv_gcd (int a, int b, int[] res) {
        if (a == 0) {
            res[0] = 0;
            res[1] = 1;
            return b;
	}
	int[] ar = new int[2];
	int d = adv_gcd (b % a, a, ar);
	res[0] = ar[1] - (b / a) * ar[0];
	res[1] = ar[0];
	return d;
    }

    //return such x and y that a*x + b*y == c
    //if x == y == Integer.MAX_VALUE then there's no integer decision
    public int[] findXY (int a, int b, int c) {
        int[] tmp = new int[2];
        int var = adv_gcd (a, b, tmp);
        if (c % var != 0) {
            return new int[] {Integer.MAX_VALUE, Integer.MAX_VALUE};
        }
        else {
            return new int[] {tmp[0] * (c / var), tmp[1] * (c / var)};
        }
    }

    public long[] __solve (int a, int b, int c) {
        int[] tmp = new int[2];
        int var = adv_gcd (a, b, tmp);
        if (c % var != 0) {
            return new long[] {Long.MAX_VALUE, Long.MAX_VALUE};
        }
        else {
            return new long[] {(tmp[0] + 0L) * (c / var), (tmp[1] + 0L) * (c / var)};
        }
    }
    //-------------------------------

    public static void main(String[] args) {
        new Main().run();
    }

    BufferedReader in;
    StringTokenizer tokenizer;
    PrintWriter out;

    public void run() {
        try {
            in = new BufferedReader(new InputStreamReader(System.in));
            tokenizer = null;
            out = new PrintWriter(System.out);
            solve();
            in.close();
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

    int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }

    long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }

    double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }

    String nextToken() throws IOException {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            tokenizer = new StringTokenizer(in.readLine());
        }
        return tokenizer.nextToken();
    }
}