Problem: In Walrusland public transport tickets are characterized by two integers: by the number of the series and by the number of the ticket in the series. Let the series number be represented by a and the ticket number — by b, then a ticket is described by the ordered pair of numbers (a, b). 

The walruses believe that a ticket is lucky if a * b = rev(a) * rev(b). The function rev(x) reverses a number written in the decimal system, at that the leading zeroes disappear. For example, rev(12343) = 34321, rev(1200) = 21.

The Public Transport Management Committee wants to release x series, each containing y tickets, so that at least w lucky tickets were released and the total number of released tickets (x * y) were minimum. The series are numbered from 1 to x inclusive. The tickets in each series are numbered from 1 to y inclusive. The Transport Committee cannot release more than maxx series and more than maxy tickets in one series.

Input

The first line contains three integers maxx, maxy, w (1 ≤ maxx, maxy ≤ 105, 1 ≤ w ≤ 107).

Output

Print on a single line two space-separated numbers, the x and the y. If there are several possible variants, print any of them. If such x and y do not exist, print a single number  - 1.

Examples

Input

2 2 1


Output

1 1

Input

132 10 35


Output

7 5

Input

5 18 1000


Output

-1


Input

48 132 235


Output

22 111

Solution (in JAVA):

Solution:
import java.io.IOException;
import java.util.*;

/**
 * Author: dened
 * Date: 26.03.11
 */
public class C {
    public static void main(String[] args) throws IOException {
        Scanner in = new Scanner(System.in);
        int mx = in.nextInt();
        int my = in.nextInt();
        int w = in.nextInt();
        Map<Map.Entry<Integer, Integer>, List<Integer>> map = new HashMap<Map.Entry<Integer, Integer>, List<Integer>>();

        for (int a = 1; a <= Math.max(mx, my); ++a) {
            int b = rev(a);
            Map.Entry<Integer, Integer> key = getKey(b, a);
            List<Integer> list = map.get(key);
            if (list == null) {
                list = new ArrayList<Integer>();
                map.put(key, list);
            }
            list.add(a);
        }

        int[] c = new int[Math.max(mx, my) + 1];
        int p = c.length - 1;
        long s = 0;
        long ans = Long.MAX_VALUE;
        int ansx = 0;
        int ansy = 0;
        for (int a = 1; a <= Math.min(mx, my); ++a) {
            List<Integer> list = map.get(getKey(a, rev(a)));
            if (list != null) {
                for (int b : list) {
                    if (b <= p) {
                        ++c[b];
                        ++s;
                        while (s - c[p] >= w) {
                            s -= c[p];
                            --p;
                        }
                    }
                }
            }
            if (s >= w && (long)a*p < ans) {
                ans = (long)a*p;
                ansx = a;
                ansy = p;
            }
        }
        if (ans != Long.MAX_VALUE) {
            if (ansx > mx || ansy > my) {
                System.out.println(ansy + " " + ansx);
            }
            else {
                System.out.println(ansx + " " + ansy);
            }
        }
        else {
            System.out.println(-1);
        }
    }

    private static Map.Entry<Integer, Integer> getKey(int a, int b) {
        int d = gcd(a, b);

        return new AbstractMap.SimpleEntry<Integer, Integer>(a / d, b / d);
    }

    private static int rev(int a) {
        int b = 0;
        int t = a;
        while (t > 0) {
            b *= 10;
            b += t % 10;
            t /= 10;
        }
        return b;
    }

    static int gcd(int x, int y) {
        return y == 0 ? x : gcd(y, x % y);
    }
}