#include <bits/stdc++.h>

int n;
int m;
int arr[100001];
int it[200002];

void
build(int beg,
      int end,
      int index)
{
    if (beg == end)
    {
        it[index] = arr[beg];
    }
    else
    {
        build(beg,
              (beg + end) / 2,
              2 * index);
        build((beg + end) / 2 + 1,
              end,
              2 * index + 1);
        it[index] = std::max(it[2 * index], it[2 * index + 1]);
    }
}

int
query(int beg,
      int end,
      int b,
      int e,
      int index)
{
    int mid;
    int res;

    if (beg > end)
    {
        return std::numeric_limits <int>::min();
    }
    
    if ( (beg == b) and
         (end == e) )
    {
        return it[index];
    }

    mid = (beg + end) / 2;

    if (mid < b)
    {
        res = query(mid + 1,
                    end,
                    b,
                    e,
                    2 * index + 1);
    }
    else if (mid >= e)
    {
        res = query(beg,
                    mid,
                    b,
                    e,
                    2 * index);
    }
    else
    {
        res = std::max(query(beg, mid, b, mid, 2 * index),
                       query(mid + 1, end, mid + 1, e, 2 * index + 1));
    }

    return res;
}

void
update(int pos,
       int val,
       int beg,
       int end,
       int index)
{
    if (beg == end)
    {
        it[index] = val;
    }
    else
    {
        if (pos > (beg + end) / 2)
        {
            update(pos,
                   val,
                   (beg + end) / 2 + 1,
                   end,
                   2 * index + 1);
        }
        else
        {
            update(pos,
                   val,
                   beg,
                   (beg + end) / 2,
                   2 * index);
        }

        it[index] = std::max(it[2 * index],
                             it[2 * index + 1]);
    }
}

int main()
{
    int index;
    int op;
    int x;
    int y;

    std::ifstream mama("arbint.in");
    std::ofstream tata("arbint.ouy");

    mama >> n;
    mama >> m;

    for (index = 1; index <= n; ++index)
    {
        mama >> arr[index];
    }

    build(1, n, 1);

    for (index = 0; index < m; ++index)
    {
        mama >> op;
        mama >> x;
        mama >> y;

        if (0 == op)
        {
            tata << query(1, n, x, y, 1) << '\n';
        }
        else
        {
            update(x, y, 1, n, 1);
        }
    }

    return 0;
}