import std.conv, std.stdio, std.string;
import std.algorithm, std.array, std.bigint, std.container, std.math, std.range, std.regex, std.typecons;
import core.bitop;

class EOFException : Throwable { this() { super("EOF"); } }
string[] tokens;
string readToken() { for (; tokens.empty; ) { if (stdin.eof) throw new EOFException; tokens = readln.split; } auto token = tokens[0]; tokens.popFront; return token; }
int readInt() { return readToken().to!int; }
long readLong() { return readToken().to!long; }
real readReal() { return readToken().to!real; }

void chmin(T)(ref T t, in T f) { if (t > f) t = f; }
void chmax(T)(ref T t, in T f) { if (t < f) t = f; }

int binarySearch(T)(in T[] as, in bool delegate(T) test) { int low = -1, upp = cast(int)(as.length); for (; low + 1 < upp; ) { int mid = (low + upp) >> 1; (test(as[mid]) ? low : upp) = mid; } return upp; }
int lowerBound(T)(in T[] as, in T val) { return as.binarySearch((T a) => (a < val)); }
int upperBound(T)(in T[] as, in T val) { return as.binarySearch((T a) => (a <= val)); }


immutable INF = 10^^9 + 10;

long[] X;

void main() {
  long[] P = [0, 1, 0];
  long[] Q = [0, 0, 1];
  for (; ; ) {
    const p = P[$ - 1] + P[$ - 2];
    const q = Q[$ - 1] + Q[$ - 2];
    if (p + q > INF) {
      break;
    }
    P ~= p;
    Q ~= q;
  }
  const len = cast(int)(P.length);
  debug {
    writefln("len = %s", len);
    writefln("P = %s", P);
    writefln("Q = %s", Q);
  }
  
  try {
    for (; ; ) {
      X = new long[3];
      foreach (h; 0 .. 3) {
        X[h] = readLong();
      }
      X = X.sort.uniq.array;
      auto ans = Tuple!(long, long)(INF, INF);
      if (X.length == 1) {
        // a = 1 ok
        if (X[0] == 1) {
          ans = tuple(1L, 1L);
        } else {
          foreach (i; 2 .. len) {
            /*
              P[i] + Q[i] b = X[0]
            */
            if ((X[0] - P[i]) % Q[i] == 0) {
              auto b = (X[0] - P[i]) / Q[i];
              if (b > 0) {
                chmin(ans, tuple!(long, long)(1L, b));
              }
            }
          }
        }
      } else {
        foreach (i; 1 .. len) foreach (j; i + 1 .. len) {
          /*
            P[i] a + Q[i] b = X[0]
            P[j] a + Q[j] b = X[1]
          */
          const dnm = P[i] * Q[j] - Q[i] * P[j];
          const nmrA = X[0] * Q[j] - Q[i] * X[1];
          const nmrB = P[i] * X[1] - X[0] * P[j];
          assert(dnm != 0);
          if (nmrA % dnm == 0 && nmrB % dnm == 0) {
            const a = nmrA / dnm;
            const b = nmrB / dnm;
            if (a > 0 && b > 0) {
              bool ok = true;
              foreach (h; 2 .. X.length) {
                bool found;
                foreach (k; 1 .. len) {
                  found = found || (P[k] * a + Q[k] * b == X[h]);
                }
                ok = ok && found;
              }
              if (ok) {
                chmin(ans, tuple!(long, long)(a, b));
              }
            }
          }
        }
      }
      if (ans >= tuple(INF, INF)) {
        writeln(-1);
      } else {
        writeln(ans[0], " ", ans[1]);
      }
    }
  } catch (EOFException e) {
  }
}