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

import java.util.HashMap;
import java.util.Scanner;

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

/**
 *
 * @author duc
 */
public class CF70_C {
    static int reverseNumber(int n) {
        int m = 0;
        while (n > 0) {
            m = m * 10 + n%10;
            n/=10;
        }
        return m;
    }

    public static void main(String [] args) {
        Scanner in = new Scanner(System.in);

        int maxX, maxY, w;
        maxX = in.nextInt();
        maxY = in.nextInt();
        w = in.nextInt();

        int max = Math.max(maxX, maxY);
        int [] reverse = new int[max+1];
        for (int i = 1; i <= max; ++i) {
            reverse[i] = reverseNumber(i);
        }

        HashMap<Double, Integer> left = new HashMap<Double, Integer>();
        HashMap<Double, Integer> right = new HashMap<Double, Integer>();
        left.put(1.0, 1);

        long nLucky = 0;

        int bestArea = Integer.MAX_VALUE, bestX = -1, bestY = -1;

        int y;

        for (y = 1; y <= maxY; ++y) {
            double ratio = (double) reverse[y] / y;
            right.put(ratio, right.containsKey(ratio) ? (right.get(ratio) + 1) : 1);
            nLucky += left.containsKey(ratio) ? left.get(ratio) : 0;
            if (nLucky >= w) {
                if (y < bestArea) {
                    bestArea = y;
                    bestX = 1;
                    bestY = y;
                }
                break;
            }
        }
        if (y > maxY) {
            y = maxY;
        }

        for (int x = 2; x <= maxX; ++x) {
            double ratioLeft = (double) x / reverse[x];
            left.put(ratioLeft, left.containsKey(ratioLeft) ? (left.get(ratioLeft) + 1) : 1);
            nLucky += right.containsKey(ratioLeft) ? right.get(ratioLeft) : 0;
            while (true) {
                double ratioRight = (double) reverse[y] / y;
                int loss = left.containsKey(ratioRight) ? left.get(ratioRight) : 0;
                if (nLucky - loss >= w) {
                    right.put(ratioRight, right.get(ratioRight) - 1);
                    nLucky -= loss;
                    --y;
                } else {
                    break;
                }
            }
            if (nLucky >= w && x * y < bestArea) {
                bestArea = x * y;
                bestX = x;
                bestY = y;
            }
        }

        if (bestArea == Integer.MAX_VALUE) {
            System.out.println(-1);
        } else {
            System.out.println(bestX + " " + bestY);
        }
    }
}
