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), 1 << 16);
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();
}
}
}