#include <inttypes.h>
#include <stdio.h>

int64_t
min(int64_t f, int64_t s)
{
    return (f < s ? f : s);
}

int64_t
calc_max_size(int64_t block_size, int64_t block_num_size, int64_t inode_direct_block_count)
{
    int64_t first = 1, second, block_ratio = block_size / block_num_size;
    int64_t ratio_squared, ratio_cubed;
    int64_t first_overflowed = 0;
    int64_t second_overflowed = 0;

    //first expression
    int64_t power = block_num_size * 8;
    if (power >= 63) {
        first_overflowed = 1;
    } else {
        first = first << power;
        if (__builtin_smulll_overflow(first, block_size, &first)) {
            first_overflowed = 1;
        }
    }

    //second expression
    if (__builtin_smulll_overflow(block_ratio, block_ratio, &ratio_squared)) {
        second_overflowed = 1;
    }
    if (__builtin_smulll_overflow(ratio_squared, block_ratio, &ratio_cubed)) {
        second_overflowed = 1;
    }
    if (__builtin_saddll_overflow(inode_direct_block_count, block_ratio, &second)) {
        second_overflowed = 1;
    }
    if (__builtin_saddll_overflow(second, ratio_squared, &second)) {
        second_overflowed = 1;
    }
    if (__builtin_saddll_overflow(second, ratio_cubed, &second)) {
        second_overflowed = 1;
    }
    if (__builtin_smulll_overflow(second, block_size, &second)) {
        second_overflowed = 1;
    }

    if (first_overflowed && second_overflowed) {
        return -1;
    } else if (!first_overflowed && !second_overflowed) {
        return min(first, second);
    } else if (first_overflowed && !second_overflowed) {
        return second;
    } else {
        return first;
    }
}

int
main(int argc, char *argv[])
{
    int64_t block_size, block_num_size, inode_direct_block_count;
    int64_t output, i, max = 0, i_saved = 0;
    scanf("%" SCNd64, &block_size);
    scanf("%" SCNd64, &block_num_size);
    scanf("%" SCNd64, &inode_direct_block_count);
    output = calc_max_size(block_size, block_num_size, inode_direct_block_count);
    printf("%" PRId64 "\n", output);

    for (i = 1; i <= block_size; ++i) {
        output = calc_max_size(block_size, i, inode_direct_block_count);
        if (output == -1) {
            printf("%" PRId64 "%" PRId64 "\n", i, output);
        } else if (output > max) {
            max = output;
            i_saved = i;
        }
    }

    printf("%" PRId64 "% " PRId64 "\n", i_saved, max);
    return 0;
}