#include <iostream>
#include <vector>
#include <cmath>

using namespace std;

// Hàm tính tổng các ước của n
long long sum_divisors(long long n) {
    long long sum = 0;
    for (long long i = 1; i * i <= n; ++i) {
        if (n % i == 0) {
            sum += i;
            if (n / i != i) {
                sum += n / i;
            }
        }
    }
    return sum;
}

int main() {
    int n;
    cin >> n;
    vector<long long> a(n);
    for (int i = 0; i < n; ++i) {
        cin >> a[i];
    }

    long long max_p_sum = -1;
    long long result_val = -1;

    // Duyệt qua mỗi phần tử để tính u và v
    for (int j = 0; j < n; ++j) {
        long long u = 0;
        long long v = 0;

        // Tính u: số lượng phần tử trước j có giá trị > a[j]
        for (int i = 0; i < j; ++i) {
            if (a[i] > a[j]) {
                u++;
            }
        }

        // Tính v: số lượng phần tử sau j có giá trị < a[j]
        for (int k = j + 1; k < n; ++k) {
            if (a[k] < a[j]) {
                v++;
            }
        }

        // Chỉ xét nếu cả u và v đều dương
        if (u > 0 && v > 0) {
            long long p = u * v;
            long long current_p_sum = sum_divisors(p);
            if (current_p_sum > max_p_sum) {
                max_p_sum = current_p_sum;
                result_val = a[j];
            }
        }
    }

    if (result_val == -1) {
        cout << "Neu khong co Thuong, Tai se buon biet may :(." << endl;
    } else {
        cout << max_p_sum << " " << result_val << endl;
    }

    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>

using namespace std;

// Hàm tính tổng các ước của n
long long sum_divisors(long long n) {
    long long sum = 0;
    for (long long i = 1; i * i <= n; ++i) {
        if (n % i == 0) {
            sum += i;
            if (n / i != i) {
                sum += n / i;
            }
        }
    }
    return sum;
}

struct Element {
    long long val;
    int index;
};

// Hàm so sánh cho BIT hoặc Merge Sort
bool compareElements(const Element &a, const Element &b) {
    if (a.val != b.val) return a.val < b.val;
    return a.index < b.index;
}

int main() {
    int n;
    cin >> n;
    vector<long long> a(n);
    for (int i = 0; i < n; ++i) {
        cin >> a[i];
    }

    // 1. Tính mảng U (Greater Elements Before)
    // Sử dụng Fenwick Tree (BIT) hoặc Merge Sort để đếm số lượng phần tử lớn hơn ở trước
    // Đơn giản hơn: Dùng set/ordered_set để đếm trong lúc duyệt
    // Tuy nhiên, do giới hạn code, ta có thể dùng cách đếm trực tiếp hoặc tối ưu O(n log n)
    // Ở đây minh họa cách dùng BIT cho bài toán Inversion Count (đảo ngược điều kiện)

    vector<int> u_counts(n, 0);
    vector<int> v_counts(n, 0);

    // Tính U: Số lượng phần tử trước j > a[j]
    // Ta có thể dùng Fenwick Tree sau khi chuẩn hóa giá trị
    // Hoặc đơn giản là dùng multiset để đếm
    {
        vector<long long> temp = a;
        sort(temp.begin(), temp.end());
        temp.erase(unique(temp.begin(), temp.end()), temp.end());

        // Fenwick Tree
        vector<int> bit(n + 1, 0);
        auto update = [&](int idx, int val) {
            for (; idx <= n; idx += idx & -idx) bit[idx] += val;
        };
        auto query = [&](int idx) {
            int sum = 0;
            for (; idx > 0; idx -= idx & -idx) sum += bit[idx];
            return sum;
        };

        // Duyệt từ trái sang phải
        for (int i = 0; i < n; ++i) {
            int pos = lower_bound(temp.begin(), temp.end(), a[i]) - temp.begin() + 1;
            // Số lượng phần tử nhỏ hơn hoặc bằng hiện tại đã xuất hiện là query(pos)
            // Số lượng phần tử lớn hơn hiện tại đã xuất hiện là i - query(pos)
            u_counts[i] = i - query(pos);
            update(pos, 1);
        }
    }

    // Tính V: Số lượng phần tử sau j < a[j]
    // Tương tự, duyệt từ phải sang trái
    {
        vector<long long> temp = a;
        sort(temp.begin(), temp.end());
        temp.erase(unique(temp.begin(), temp.end()), temp.end());

        vector<int> bit(n + 1, 0);
        auto update = [&](int idx, int val) {
            for (; idx <= n; idx += idx & -idx) bit[idx] += val;
        };
        auto query = [&](int idx) {
            int sum = 0;
            for (; idx > 0; idx -= idx & -idx) sum += bit[idx];
            return sum;
        };

        // Duyệt từ phải sang trái
        for (int i = n - 1; i >= 0; --i) {
            int pos = lower_bound(temp.begin(), temp.end(), a[i]) - temp.begin() + 1;
            // Số lượng phần tử nhỏ hơn a[i] đã xuất hiện (ở bên phải) là query(pos - 1)
            v_counts[i] = query(pos - 1);
            update(pos, 1);
        }
    }

    long long max_p_sum = -1;
    long long result_val = -1;

    for (int j = 0; j < n; ++j) {
        long long u = u_counts[j];
        long long v = v_counts[j];

        if (u > 0 && v > 0) {
            long long p = u * v;
            long long current_p_sum = sum_divisors(p);
            if (current_p_sum > max_p_sum) {
                max_p_sum = current_p_sum;
                result_val = a[j];
            }
        }
    }

    if (result_val == -1) {
        cout << "Neu khong co Thuong, Tai se buon biet may :(." << endl;
    } else {
        cout << max_p_sum << " " << result_val << endl;
    }

    return 0;
}