#include <iostream>
#include <stdio.h>
#include <map>

using namespace std;

#define mmap map<pair<int32_t, int32_t>, int32_t>

int32_t constructInterval_t(int32_t *buffer, int32_t left, int32_t right, mmap &response) {
  if(left >= right) {
    response[make_pair(left, left)] = buffer[left];
    return buffer[left];
  }
  int32_t middle = (right + left) / 2;
  int32_t leftMin = constructInterval_t(buffer, left, middle, response);
  int32_t rightMin = constructInterval_t(buffer, middle + 1, right, response);
  int32_t minValue = max(leftMin, rightMin);
  response[make_pair(left, right)] = minValue;
  return minValue;
}

mmap constructInterval(int32_t *buffer, int32_t sz) {
  mmap resp;
  constructInterval_t(buffer, 0, sz - 1, resp);
  return resp;
}

void updateTree_t(int32_t left, int32_t right, int32_t index, int32_t element, mmap &response) {
  if(left == right && index == left) {
    response[make_pair(left, right)] = element;
    return ;
  }
  if(index < left || index > right) {
    return ;
  }
  int32_t middle = (right + left) / 2;
  updateTree_t(left, middle, index, element, response);
  updateTree_t(middle + 1, right, index, element, response);
  if(left <= index && right >= index) {
    response[make_pair(left, right)] = max(response[make_pair(left, middle)], response[make_pair(middle + 1, right)]);
  }
}

void updateTree(int32_t index, int32_t element, int32_t n, mmap &response) {
  updateTree_t(0, n, index, element, response);
}

int32_t getMinInterval_t(int32_t left, int32_t right, int32_t leftDesired, int32_t rightDesired, mmap &response) {
  if(left >= leftDesired && right <= rightDesired) {
    return response[make_pair(left, right)];
  }
  if((left < leftDesired && right < leftDesired) || (left > rightDesired && right > rightDesired)) {
    return 0;
  }
  int32_t middle = (right + left) / 2;
  return max(getMinInterval_t(left, middle, leftDesired, rightDesired, response), getMinInterval_t(middle + 1, right, leftDesired, rightDesired, response));
}

int32_t getMinInterval(int32_t left, int32_t right, int32_t n, mmap &response) {
  return getMinInterval_t(0, n, left, right, response);
}

int main() {
  int32_t n, m, *buffer = (int32_t *)malloc(sizeof(int32_t) * 100001);
  FILE *fd = fopen("arbint.in", "r+");
  FILE *fr = fopen("arbint.out", "w+");
  fscanf(fd, "%d %d", &n, &m);
  for(int32_t i = 0; i < n; i++) {
    fscanf(fd, "%d", &buffer[i]);
  }
  mmap resp = constructInterval(buffer, n);
  free(buffer);
  for(int32_t i = 0; i < m; i++) {
    int32_t a, b, c;
    fscanf(fd, "%d %d %d", &c, &a, &b);
    if(!c) {
      fprintf(fr, "%d\n", getMinInterval(a - 1, b - 1, n - 1, resp));
    }
    else {
      updateTree(a - 1, b, n - 1, resp);
    }
  }
}