#include <algorithm>
#include <iostream>
#include <utility>
#include <vector>


template<class T>
class SegmentTree {
public:
    explicit SegmentTree(const std::vector<T> &numbers) : numbers_amount_(static_cast<int>(numbers.size())),
                                                          segment_tree_(2 * numbers_amount_) {
        for (int index = 0; index < numbers_amount_; ++index) {
            segment_tree_[numbers_amount_ + index] = {numbers[index], index};
        }
        for (int index = numbers_amount_ - 1; index > 0; --index) {
            segment_tree_[index] = std::max(segment_tree_[2 * index], segment_tree_[2 * index + 1]);
        }
    }

    std::pair<T, int> GetMax(int left, int right) {
        Item max = {segment_tree_[left + numbers_amount_].value, left};
        left += numbers_amount_;
        right += numbers_amount_;
        while (left < right) {
            if (left % 2) {
                max = std::max(max, segment_tree_[left++]);
            }
            if (right % 2) {
                max = std::max(max, segment_tree_[--right]);
            }
            left /= 2;
            right /= 2;
        }
        return {max.value, max.position};
    }

    void Update(int position, T value) {
        segment_tree_[position + numbers_amount_] = {value, position};
        position += numbers_amount_;
        while (position > 1) {
            position /= 2;
            segment_tree_[position] = std::max(segment_tree_[2 * position], segment_tree_[2 * position + 1]);
        }
    }

private:
    struct Item {
        T value;
        int position;

        Item() = default;

        Item(T value, int position) : value(value), position(position) {}

        bool operator<(const Item& other) const {
            return value < other.value || value == other.value && position > other.position;
        }
    };

    int numbers_amount_;

    std::vector<Item> segment_tree_;
};


int main() {
    int amount_numbers;
    std::cin >> amount_numbers;
    std::vector<int> numbers(amount_numbers);
    for (auto &number : numbers) {
        std::cin >> number;
    }

    auto segment_tree = SegmentTree<int>(numbers);

    int queries_amount;
    std::cin >> queries_amount;
    while (queries_amount--) {
        char command;
        std::cin >> command;
        switch (command) {
            case 'u':
                int position, value;
                std::cin >> position >> value;
                segment_tree.Update(position - 1, value);
                break;
            case 's':
                int left, right;
                std::cin >> left >> right;
                auto max = segment_tree.GetMax(left - 1, right);
                std::cout << max.second + 1 << " ";
                break;
        }
    }

    return 0;
}