#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

struct Inversion {
    int index;
    int value;
};

int main() {
    int N;
    cin >> N;
    vector<int> S(N);
    for (int i = 0; i < N; ++i) {
        cin >> S[i];
    }

    pair<int, int> max_inversion(-1, -1);
    int max_distance = -1;
    vector<Inversion> inversions;

    // Párosítjuk a számokat az indexükkel, majd rendezzük az értékek szerint
    for (int i = 0; i < N; ++i) {
        inversions.push_back({i + 1, S[i]});
    }
    sort(inversions.begin(), inversions.end(), [](const Inversion& a, const Inversion& b) {
        return a.value < b.value;
    });

    vector<int> fenwick_tree(N + 1, 0);

    auto update = [&](int pos) {
        while (pos <= N) {
            fenwick_tree[pos] += 1;
            pos += pos & -pos;
        }
    };

    auto query = [&](int pos) {
        int sum = 0;
        while (pos > 0) {
            sum += fenwick_tree[pos];
            pos -= pos & -pos;
        }
        return sum;
    };

    for (int i = N - 1; i >= 0; --i) {
        int index = inversions[i].index;
        int inversion_count = query(index);
        if (inversion_count > 0) {
            int farthest = index + inversion_count;
            if (farthest <= N && farthest - index > max_distance) {
                max_distance = farthest - index;
                max_inversion = {index, farthest};
            }
        }
        update(index);
    }

    if (max_distance > 0) {
        cout << max_inversion.first << " " << max_inversion.second << endl;
    } else {
        cout << "-1" << endl;
    }
    return 0;
}