import java.io.*;
import java.util.Scanner;

public class Main {
    private static final int NMAX = 100005;
    private static int[] segmentTree = new int[4 * NMAX];
    private static int n;

    public static void main(String[] args) throws IOException {
        Scanner scanner = new Scanner(new File("arbint.in"));
        FileWriter fileWriter = new FileWriter(new File("arbint.out"));

        n = scanner.nextInt();
        int q = scanner.nextInt();

        for(int i = 1; i <= n; ++i)
            Update(i, scanner.nextInt());

        while(q-- > 0)
            if (scanner.nextInt() == 0)
                fileWriter.write(String.valueOf(Query(scanner.nextInt(), scanner.nextInt())) + "\n");
            else
                Update(scanner.nextInt(), scanner.nextInt());

        fileWriter.close();
    }

    private static void Update(int indexToUpdate, int newValue) {
        Update(indexToUpdate, newValue, 1, n, 1);
    }

    private static void Update(int indexToUpdate, int newValue, int left, int right, int currentIndex) {
        if(left == right) {
            segmentTree[currentIndex] = newValue;
        } else {
            int middle = left + (right - left) / 2;

            if (indexToUpdate <= middle) {
                Update(indexToUpdate, newValue, left, middle, currentIndex << 1);
            } else {
                Update(indexToUpdate, newValue, middle + 1, right, (currentIndex << 1) + 1);
            }

            segmentTree[currentIndex] = Math.max(segmentTree[currentIndex << 1], segmentTree[(currentIndex << 1) + 1]);
        }
    }

    private static int Query(int leftQuery, int rightQuery) {
        return Query(leftQuery, rightQuery, 1, n, 1);
    }

    private static int Query(int leftQuery, int rightQuery, int left, int right, int currentIndex) {
        // [(      )]
        if(left == leftQuery && rightQuery == right) {
            return segmentTree[currentIndex];
        } else {
            int middle = left + (right - left) / 2;
            // [ ( | ) ]
            if(leftQuery <= middle && middle < rightQuery)
                return Math.max(
                    Query(leftQuery, middle, left, middle, currentIndex << 1),
                    Query(middle + 1, rightQuery, middle + 1, right, (currentIndex << 1) + 1));
            else
                // [ ( ) |     ]
                if(leftQuery <= middle && rightQuery <= middle)
                    return  Query(leftQuery, rightQuery, left, middle, currentIndex << 1);
                // [     | ( ) ]
                else
                    return Query(leftQuery, rightQuery, middle + 1, right, (currentIndex << 1) + 1);
        }
    }
}