#include <fstream>
#include <algorithm>

const int N = 100005;

int segment_tree[N * 4], array[N];

void build(int node, int left, int right)
{
  if (left == right) {
    segment_tree[node] = array[left];
  } else {
    int middle = (left + right) / 2;

    build(node * 2, left, middle);
    build(node * 2 + 1, middle + 1, right);

    segment_tree[node] = std::max(segment_tree[node * 2], 
                                  segment_tree[node * 2 + 1]);
  }
}

void update(int node, int left, int right, int position, int new_value)
{
  if (left == right) {
    segment_tree[node] = new_value;
  } else {
    int middle = (left + right) / 2;

    if (position <= middle)
      update(node * 2, left, middle, position, new_value);
    else
      update(node * 2 + 1, middle + 1, right, position, new_value);

    segment_tree[node] = std::max(segment_tree[node * 2], 
                              segment_tree[node * 2 + 1]);
  }
}

int query(int node, int left, int right, int query_left, int query_right)
{
  if (query_left <= left and right <= query_right) {
    return segment_tree[node];
  } else {
    int middle = (left + right) / 2;

    if (query_right <= middle)
      return query(node * 2, left, middle, query_left, query_right);
    if (middle + 1 <= query_left)
      return query(node * 2 + 1, middle + 1, right, query_left, query_right);

    return std::max(query(node * 2, left, middle, query_left, query_right),
                    query(node * 2 + 1, middle + 1, right, query_left, query_right));
  }
}

int main(void) 
{
  std::ifstream in("arbint.in");
  std::ofstream out("arbint.out");

  int n, q; 
  in >> n >> q;

  for (int i = 1; i <= n; ++i)
    in >> array[i];

  build(1, 1, n);

  while (q--) {
    int t;
    in >> t;

    if (t == 0) {
      int left, right;
      in >> left >> right;
      out << query(1, 1, n, left, right) << "\n";
    } else {
      int position, new_value;
      in >> position >> new_value;
      update(1, 1, n, position, new_value);
    }
  }

  return 0;
}