import java.io.*;
import java.util.StringTokenizer;

public class Main {

    public static void main(String[] args) throws IOException {
        InputStream inputStream = new FileInputStream("arbint.in");
        OutputStream outputStream = new FileOutputStream("arbint.out");

        try (InputReader inputReader = new InputReader(inputStream);
             PrintWriter printWriter = new PrintWriter(outputStream)) {
            Solver.solve(inputReader, printWriter);
        }
    }

    static class Solver {

        public static void solve(InputReader inputReader, PrintWriter printWriter) {
            int N = inputReader.nextInt();
            int numberOperations = inputReader.nextInt();
            int[] initialValues = new int[N + 1];
            for (int node = 1; node <= N; node++) {
                initialValues[node] = inputReader.nextInt();
            }

            ArbInt arbInt = new ArbInt(N, initialValues);
            for (int opNo = 1; opNo <= numberOperations; opNo++) {
                int opType = inputReader.nextInt();
                int a = inputReader.nextInt();
                int b = inputReader.nextInt();
                switch (opType) {
                    case 1:
                        arbInt.update(a, b);
                        break;
                    case 0:
                        printWriter.println(arbInt.getMax(a, b));
                        break;
                }
            }
        }

    }

    static class ArbInt {
        private static final int INF = Integer.MAX_VALUE >> 1;

        private int N;
        private int[] nodes;

        public ArbInt(int N, int[] initialValues) {
            this.N = N;
            int closestPowerOfTwo = 1;
            while (closestPowerOfTwo < N) {
                closestPowerOfTwo *= 2;
            }

            nodes = new int[closestPowerOfTwo * 2];
            cstrTree(1, N, 1, initialValues);
        }

        private void cstrTree(int left, int right, int currNode, int[] intitialValues) {
            if (left == right) {
                nodes[currNode] = intitialValues[left];
                return ;
            }

            int mid = (left + right) / 2;
            cstrTree(left, mid, currNode * 2, intitialValues);
            cstrTree(mid + 1, right, currNode * 2 + 1, intitialValues);
            nodes[currNode] = Math.max(nodes[currNode * 2] , nodes[currNode * 2 + 1]);
        }

        public void update(int pos, int value) {
            update(1, N, 1, pos, value);
        }

        public int getMax(int from, int to) {
            return getMax(1, N, 1, from, to);
        }

        private int getMax(int left, int right, int node, int from, int to) {
            // no inters
            if (right < from || to < left) {
                return -INF;
            }
            // [left, right] is included in [from, to]
            if (from <= left && right <= to) {
                return nodes[node];
            }

            int mid = (left + right) / 2;
            return Math.max(
                    getMax(left, mid, node * 2, from, to),
                    getMax(mid + 1, right, node * 2 + 1, from, to));
        }

        private void update(int left, int right, int node, int pos, int value) {
            if (left == right) {
                assert(left == pos);
                nodes[node] = value;
                return;
            }

            int mid = (left + right) / 2;
            if (pos <= mid) {
                update(left, mid, node * 2, pos, value);
            } else {
                update(mid + 1, right, node * 2 + 1, pos, value);
            }

            nodes[node] = Math.max(nodes[node * 2], nodes[node * 2 + 1]);
        }
    }

    static class InputReader implements AutoCloseable {
        private BufferedReader bufferedReader;

        private StringTokenizer stringTokenizer;

        public InputReader(InputStream inputStream) {
            bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
            stringTokenizer = null;
        }

        private String nextToken() {
            if (stringTokenizer == null || !stringTokenizer.hasMoreTokens()) {
                try {
                    stringTokenizer = new StringTokenizer(bufferedReader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }

            return stringTokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(nextToken());
        }

        @Override
        public void close() throws IOException {
            bufferedReader.close();
        }
    }
}