class IntervalTree:
    __n: int
    __tree: list[int]

    def __init__(self, elements: list[int]):
        self.__n = len(elements)
        self.__tree = [-1 for _ in range(2 * self.__n)]

        self.__build(1, 1, self.__n, elements)

    def __build(self, node: int, left: int, right: int, elements: list[int]):
        if left == right:
            self.__tree[node] = elements[left - 1]
            return

        middle = (left + right)//2

        self.__build(node * 2, left, middle, elements)
        self.__build(node * 2 + 1, middle + 1, right, elements)

        self.__tree[node] = max(self.__tree[node * 2],
                                self.__tree[node * 2 + 1])

    def __update(self, node: int, left: int, right: int, index: int,
                 value: int):
        if left == right:
            self.__tree[node] = value
            return

        middle = (left + right) // 2
        if left <= index <= middle:
            self.__update(node * 2, left, middle, index, value)
        else:
            self.__update(node * 2 + 1, middle + 1, right, index, value)

        self.__tree[node] = max(self.__tree[node * 2],
                                self.__tree[node * 2 + 1])

    def change_element(self, index: int, value: int):
        self.__update(1, 1, self.__n, index, value)

    def __query(self, node: int, left: int, right: int, left_index: int,
                right_index: int):
        if left_index <= left and right <= right_index:
            return self.__tree[node]

        middle = (left + right) // 2

        result = -1
        if left_index <= middle:
            result = self.__query(node * 2, left, middle, left_index,
                                  right_index)

        if right_index >= middle + 1:
            result = max(result, self.__query(node * 2 + 1, middle + 1, right,
                                              left_index, right_index))

        return result

    def get_max(self, left_index: int, right_index: int):
        return self.__query(1, 1, self.__n, left_index, right_index)


def main():
    with open("arbint.in") as fdr:
        [_, m] = map(int, fdr.readline().split())

        interval_tree = IntervalTree(list(map(int, fdr.readline().split())))

        with open("arbint.out", "w") as fdw:
            for _ in range(m):
                [op, a, b] = map(int, fdr.readline().split())

                if op:
                    interval_tree.change_element(a, b)
                else:
                    fdw.write(f"{interval_tree.get_max(a, b)}\n")


if __name__ == '__main__':
    main()