import java.io.*;
import java.util.Objects;

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

    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new FileReader("arbint.in"));
        BufferedWriter writer = new BufferedWriter(new FileWriter("arbint.out"));

        String[] tokens = reader.readLine().split(" ");
        n = Integer.parseInt(tokens[0]);
        q = Integer.parseInt(tokens[1]);

        tokens = reader.readLine().split(" ");
        for(int i = 1; i <= n; ++i) Update(i, Integer.parseInt(tokens[i - 1]));

        while(q-- > 0) {
            tokens = reader.readLine().split(" ");

            if (tokens[0].equals("0"))
                writer.write(String.valueOf(Query(Integer.parseInt(tokens[1]), Integer.parseInt(tokens[2]))) + "\n");
            else
                Update(Integer.parseInt(tokens[1]), Integer.parseInt(tokens[2]));
        }

        reader.close();
        writer.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) >> 1;

            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(leftQuery <= left && right <= rightQuery) {
            return segmentTree[currentIndex];
        } else {
            int middle = (left + right) >> 1;
            // [ ( | ) ]
            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(rightQuery <= middle)
                    return  Query(leftQuery, rightQuery, left, middle, currentIndex << 1);
                // [     | ( ) ]
                else
                    return Query(leftQuery, rightQuery, middle + 1, right, (currentIndex << 1) + 1);
        }
    }
}