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 java.io.*;
import java.math.BigInteger;
import java.util.*;

public class Main {
    public static class Solver {
        FastScanner in = new FastScanner();
        PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));

        public class FastScanner {
            public static final String STANDARD_DELIMS = " \t\n\r\f";

            public FastScanner() {
                delims = STANDARD_DELIMS;
                br = getReaderFor(System.in);
            }

            public FastScanner(InputStream in) {
                delims = STANDARD_DELIMS;
                br = getReaderFor(in);
            }

            public FastScanner(String delims) {
                this.delims = delims;
                br = getReaderFor(System.in);
            }

            public FastScanner(InputStream in, String delims) {
                this.delims = delims;
                br = getReaderFor(in);
            }

            String nextToken() {
                while (st == null || !st.hasMoreElements()) {
                    try {
                        st = new StringTokenizer(br.readLine(), delims);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                return st.nextToken();
            }

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

            private BufferedReader br;
            private StringTokenizer st;
            private String delims;

            private BufferedReader getReaderFor(InputStream in) {
                return new BufferedReader(new InputStreamReader(in));
            }
        }

        <T> void println(T x) {
            System.out.println(x);
        }

        <T> void print(T x) {
            System.out.print(x);
        }

        static class ExteuResult {
            public BigInteger x, y, d;

            public ExteuResult(BigInteger x, BigInteger y, BigInteger d) {
                this.x = x;
                this.y = y;
                this.d = d;
            }
        }

        BigInteger ceil(BigInteger a, BigInteger b) {
            BigInteger[] res = a.divideAndRemainder(b);
            return res[1].equals(BigInteger.ZERO) ? res[0] : res[0].add(BigInteger.ONE);
        }

        ExteuResult exteu(BigInteger a, BigInteger b) {
            if (b.equals(BigInteger.ZERO)) {
                return new ExteuResult(BigInteger.ONE, BigInteger.ZERO, a);
            } else {
                ExteuResult res = exteu(b, a.mod(b));
                return new ExteuResult(res.y, res.x.subtract(a.divide(b).multiply(res.y)), res.d);
            }
        }

        void solve() throws Exception {
            BigInteger a = new BigInteger(in.nextToken());
            BigInteger b = new BigInteger(in.nextToken());
            BigInteger c = new BigInteger(in.nextToken());

            c = c.negate();

            int sgna = a.compareTo(BigInteger.ZERO);
            if (sgna < 0) a = a.negate();
            int sgnb = b.compareTo(BigInteger.ZERO);
            if (sgnb < 0) b = b.negate();

            if (a.equals(BigInteger.ZERO)) {
                if (c.mod(b).equals(BigInteger.ZERO)) {
                    BigInteger y = c.divide(b);
                    if (sgnb < 0) y = y.negate();
                    println(String.format("%s %s", 0, y));
                } else {
                    println("-1");
                }
                return;
            }

            if (b.equals(BigInteger.ZERO)) {
                if (c.mod(a).equals(BigInteger.ZERO)) {
                    BigInteger x = c.divide(a);
                    if (sgna < 0) x = x.negate();
                    println(String.format("%s %s", x, 0));
                } else {
                    println("-1");
                }
                return;
            }
            
            ExteuResult result = exteu(a, b);

            BigInteger d = result.d;

            if (!c.mod(d).equals(BigInteger.ZERO)) {
                println("-1");
                return;
            }

            BigInteger x0 = result.x.multiply(c.divide(d));
            BigInteger y0 = result.y.multiply(c.divide(d));

            BigInteger l = BigInteger.valueOf(-5000_000_000_000_000_000L);
            BigInteger r = BigInteger.valueOf(5000_000_000_000_000_000L);

            BigInteger bdivd = b.divide(d);
            BigInteger xkl = ceil(l.subtract(x0), bdivd);
            BigInteger xkr = r.subtract(x0).divide(bdivd);

            BigInteger adivd = a.divide(d);
            BigInteger ykl = ceil(y0.subtract(r), adivd);
            BigInteger ykr = y0.subtract(l).divide(adivd);

            BigInteger kl = xkl.max(ykl);
            BigInteger kr = xkr.min(ykr);
            if (kl.compareTo(kr) > 0) {
                println("-1");
            } else {
                BigInteger x = x0.add(bdivd.multiply(kl));
                if (sgna < 0) x = x.negate();
                BigInteger y = y0.subtract(adivd.multiply(kl));
                if (sgnb < 0) y = y.negate();
                println(String.format("%s %s", x, y));
            }

            out.close();
        }
    }

    public static void main(String[] args) throws Exception {
        new Solver().solve();
    }
}