Given an integer x, find 2 integers a and b such that: 

  * 1 ≤ a,b ≤ x 
  * b divides a (a is divisible by b). 
  * a ⋅ b>x. 
  * a/b<x. 

Input

The only line contains the integer x (1 ≤ x ≤ 100).

Output

You should output two integers a and b, satisfying the given conditions, separated by a space. If no pair of integers satisfy the conditions above, print "-1" (without quotes).

Examples

Input

10


Output

6 3

Input

1


Output

-1
//package com.company;

import java.io.*;
import java.math.BigInteger;
import java.util.*;

import static java.lang.Math.*;

public class Main {

    FastScanner in;
    PrintWriter out;
    int cnt;
    long mod = 1000000007;

    long gcd(long a, long b){
        if(b == 0){
            return a;
        }
        return  gcd(b, a%b);
    }

    class point implements Comparable<point> {
        long x;
        long t;
        int ind;

        point(int x, int t, int ind) {
            this.x = x;
            this.t = t;
            this.ind = ind;
        }

        public int compareTo(point that) {
            if(Double.compare(this.x, that.x)==0){
                if(this.t == that.t){
                    return Double.compare(this.ind, that.ind);
                }
                return (-1) * Double.compare(this.t, that.t);
            }
            return   Double.compare(this.x, that.x);
        }
    }

    long[] fact;
    long pow(long a, long n) {
        if (n == 0) {
            return 1;
        }
        if (n % 2 == 0) {
            long tmp = (pow(a, n / 2));
            return (tmp * tmp);
        } else {
            return ((pow(a, n - 1))* (a));
        }
    }


    class quemin{
        int[] stack1;
        int[] min1;
        int sz1;
        int stack2[];
        int min2[];
        int sz2;
        quemin(int n){
            stack1 = new int[n];
            min1 = new int[n];
            stack2 = new int[n];
            min2 = new int[n];
            sz1 = sz2 = 0;
        }
        void add(int x){
            stack1[sz1] = x;
            min1[sz1] = sz1 > 0 ? min(x, min1[sz1 - 1]) : x;
            sz1++;
        }
        void pop(){
            if(sz2 > 0){
                sz2--;
            } else {
                while (sz1 > 0) {
                    stack2[sz2] = stack1[sz1 - 1];
                    min2[sz2] = sz2 > 0 ? min(stack2[sz2], min2[sz2 - 1]) : stack2[sz2];
                    sz2++;
                    sz1--;
                }
                sz2--;
            }
        }
        int getmin1(){
            if(sz1 > 0){
                return min1[sz1 - 1];
            }
            return Integer.MAX_VALUE;
        }
        int getmin2(){
            if(sz2 > 0){
                return min2[sz2 - 1];
            }
            return Integer.MAX_VALUE;
        }
        int getmin(){
            return min(getmin1(), getmin2());
        }
    }

    class seg implements Comparable<seg>{
        int x;
        int y;
        seg(int x, int y){
            this.x = x;
            this.y = y;
        }

        @Override
        public int compareTo(seg o) {
            if(this.x == o.x){
                return Double.compare(this.y, o.y);
            }
            return Double.compare(this.x, o.x);
        }
    }


    private void solve2() throws IOException {
        long n = in.nextLong();
        boolean found = false;
        for(int i = 1; i <= n && !found; i++){
            for(int j = 1; j <= n && !found; j++){
                if( i % j == 0){
                    if(i * j > n && i/j < n){
                        out.print(i +  " " + j);
                        found = true;
                    }
                }
            }
        }
        if(!found){
            out.print(-1);
        }

    }

    /*private void solve() throws IOException {
        int n = in.nextInt(), m = in.nextInt();
        int[][] tab = new int[n][m];
        boolean[][] used = new boolean[n][m];
        long[][] ans = new long[n][m];
        for(int i = 0; i < n; i++){
            for(int j = 0; j < m; j++){
                tab[i][j] = in.nextInt();
            }
        }
        ArrayDeque<Pair> bf = new ArrayDeque<>();
        bf.add(new Pair(0, 0));
        boolean f = false;
        while(!bf.isEmpty()){
            Pair cur = bf.poll();
            for(int i = cur.x; i < n; i++){
                if(tab[i][cur.y] == 1){
                    if(!used[i][cur.y]){
                        used[i][cur.y] = true;
                        ans[i][cur.y] = ans[cur.x][cur.y] + 1;
                        bf.add(new Pair(i, cur.y));
                    }
                    break;
                }
                if(tab[i][cur.y] == 2){
                    out.print(ans[cur.x][cur.y] + 1);
                    break;
                }
            }
        }

    }*/



    class FastScanner {
        StringTokenizer st;
        BufferedReader br;

        FastScanner(InputStream s){
            br = new BufferedReader(new InputStreamReader(s));
        }

        String next() throws IOException {
            while(st == null || !st.hasMoreTokens()){
                st = new StringTokenizer(br.readLine());
            }
            return st.nextToken();
        }
        boolean hasNext() throws IOException {
            return br.ready() || (st != null && st.hasMoreTokens());
        }

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

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

        double nextDouble() throws IOException {
            return Double.parseDouble(next().replace(',', '.'));
        }

        boolean hasNextLine() throws IOException {
            return br.ready();
        }

        String nextLine() throws IOException {
            return br.readLine();
        }

    }

    private void run() throws IOException {
        in = new FastScanner(System.in); //new FileInputStream(".in");
        out = new PrintWriter(System.out);

        solve2();
        out.flush();
        out.close();
    }






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

    }

}