#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx")
#pragma GCC optimize("unroll-loops")
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using vi = vector<int>;
const ld PI = acos(-1);
template <typename T, typename U>
inline bool chmax(T &a, U b) {
  return a < b && (a = b, true);
}
template <typename T, typename U>
inline bool chmin(T &a, U b) {
  return a > b && (a = b, true);
}
mt19937 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
template <typename T, typename U>
std::ostream &operator<<(std::ostream &stream, const pair<T, U> &p) {
  return stream << p.first << " " << p.second;
}
template <typename T1, typename U>
istream &operator>>(istream &is, pair<T1, U> &p) {
  is >> p.first >> p.second;
  return is;
}
template <typename T>
std::ostream &operator<<(std::ostream &out, const vector<T> &vec) {
  for (const T &x : vec) out << x << ' ';
  return out;
}
template <typename T>
std::istream &operator>>(std::istream &in, vector<T> &vec) {
  for (auto &x : vec) in >> x;
  return in;
}
template <typename T>
T gcd(T a, T b) {
  a = abs(a);
  b = abs(b);
  while (b != 0) {
    a = a % b;
    swap(a, b);
  }
  return a;
}
template <typename T>
T lcm(T a, T b) {
  return a / gcd(a, b) * b;
}
template <typename T, typename U>
T power(T a, T b, U mod) {
  T res = 1;
  while (b) {
    if (b & 1) {
      res = (res * a) % mod;
    }
    a = (a * a) % mod;
    b /= 2;
  }
  return res;
}
template <typename T>
std::vector<T> powers(T base, int length) {
  std::vector<T> result(length);
  if (length > 0) {
    result[0] = 1;
  }
  for (int i = 1; i < length; i++) {
    result[i] = result[i - 1] * base;
  }
  return result;
}
bool miller_rabin(unsigned n) {
  if (n < 2) return false;
  for (unsigned p : {2, 3, 5, 7, 11, 13, 17, 19, 23, 29})
    if (n % p == 0) return n == p;
  int r = __builtin_ctz(n - 1);
  unsigned d = (n - 1) >> r;
  for (unsigned a : {2, 7, 61}) {
    unsigned x = power(a % n, d, n);
    if (x <= 1 || x == n - 1) continue;
    for (int i = 0; i < r - 1 && x != n - 1; i++)
      x = unsigned(uint64_t(x) * x % n);
    if (x != n - 1) return false;
  }
  return true;
}
struct Sieve {
  int maxn;

 public:
  using MapType = unordered_map<long long, long long>;
  std::vector<long long> spf;
  std::vector<long long> primes;
  std::vector<long long> mobius;
  std::vector<bool> is_prime;
  explicit Sieve(int _n = 2e6 + 7) : maxn(_n + 1) {
    spf.resize(maxn, 1);
    is_prime.resize(maxn, true);
    primes.clear();
    is_prime[0] = is_prime[1] = false;
    for (long long i = 2; i < maxn; ++i) {
      if (is_prime[i]) {
        primes.push_back(i);
        spf[i] = i;
      }
      for (long long j = 0; j < (int)primes.size() && (i * primes[j]) < maxn &&
                            primes[j] <= spf[i];
           ++j) {
        is_prime[i * primes[j]] = false;
        spf[i * primes[j]] = primes[j];
      }
    }
  }
  void genMobius() {
    mobius.resize(maxn, 0);
    mobius[1] = 1;
    for (long long i = 2; i < maxn; ++i) {
      if (spf[i / spf[i]] == spf[i]) {
        mobius[i] = 0;
      } else {
        mobius[i] = -mobius[i / spf[i]];
      }
    }
  }
  long long nextPrime(long long x, bool strict = false) {
    auto it = upper_bound(primes.begin(), primes.end(), x);
    if (!strict and is_prime[x]) return x;
    next(it);
    return *it;
  }
  bool isPrime(long long num) {
    if (num < maxn) {
      return is_prime[num];
    }
    for (long long div = 2; div * div <= num; ++div) {
      if (num % div == 0) return false;
    }
    return true;
  }
  long long numDivisors(long long val) {
    auto div = primeFactors(val);
    long long ans = 1;
    for (const auto &p : div) {
      ans *= p.second + 1;
    }
    return ans;
  }
  long long countDivisors(long long n) {
    if (n == 1) return 1;
    long long ans = 1;
    for (int i = 0;; i++) {
      if (primes[i] * primes[i] * primes[i] > n) break;
      int cnt = 1;
      while (n % primes[i] == 0) {
        n /= primes[i];
        cnt++;
      }
      ans *= cnt;
    }
    if (is_prime[n])
      ans = ans * 2;
    else if (is_prime[sqrt(n)] && (long long)sqrt(n) == sqrt(n))
      ans = ans * 3;
    else if (n != 1)
      ans = ans * 4;
    return ans;
  }
  vector<pair<long long, long long>> divisorPair(long long x) {
    vector<pair<long long, long long>> res;
    for (long long i = 1; i * i <= x; i++) {
      if (x % i == 0) {
        if (x / i == i) {
          res.emplace_back(i, i);
        } else {
          res.emplace_back(i, x / i);
        }
      }
    }
    return res;
  }
  vector<long long> divisor(long long x) {
    vector<long long> res;
    for (long long i = 1; i * i <= x; i++) {
      if (x % i == 0) {
        res.push_back(i);
        if ((x / i) != i) {
          res.push_back(x / i);
        }
      }
    }
    return res;
  }
  set<long long> divisorSet(long long x) {
    set<long long> res;
    for (long long i = 1; i * i <= x; i++) {
      if (x % i == 0) {
        res.insert(i);
        res.insert(x / i);
      }
    }
    return res;
  }
  MapType primeFactors(long long val) {
    MapType fac;
    while (val > 1) {
      auto pf = spf[val];
      if (pf == 1) break;
      long long cnt = 0;
      while (val % pf == 0) {
        cnt++;
        val /= pf;
      }
      fac[pf] = cnt;
    }
    return fac;
  }
  set<long long> divisorsBrute(long long val) {
    set<long long> res;
    for (long long i = 1; i * i <= val; i++) {
      if (val % i == 0) {
        if ((val / i) == i) {
          res.insert(i);
        } else {
          res.insert(i);
          res.insert(val / i);
        }
      }
    }
    return res;
  }
};
Sieve sieve(sqrt(1e9 + 7));
class CPythagoreanTriples {
 public:
  bool ok(ll h, ll y) { return h >= 1 && y >= 1 && h <= 1e18 && y <= 1e18; }
  bool solveBase(ll n) {
    auto div = sieve.divisorPair(n);
    for (auto [a1, b1] : div) {
      for (auto [a2, b2] : div) {
        for (auto [a, b] : {make_pair(a1 * a2, b1 * b2), {a1 * b2, a2 * b1}}) {
          {
            ll h = (a + b) / 2;
            ll y = (b - a) / 2;
            if (n * n == h * h - y * y && ok(h, y)) {
              cout << h << " " << y << '\n';
              return true;
            }
          }
          {
            ll y = (a + b) / 2;
            ll h = (b - a) / 2;
            if (n * n == h * h - y * y && ok(h, y)) {
              cout << h << " " << y << '\n';
              return true;
            }
          }
        }
      }
    }
    return false;
  }
  bool solveHypot(ll n) { return false; }
  void solve() {
    ll n;
    cin >> n;
    if (solveBase(n)) {
      return;
    } else if (solveHypot(n)) {
      return;
    } else {
      cout << -1 << '\n';
    }
  }
};
int32_t main() {
  std::ios::sync_with_stdio(false);
  std::cin.tie(nullptr);
  std::cout.tie(nullptr);
  CPythagoreanTriples solver;
  solver.solve();
  return 0;
}
