#include <fstream>
using namespace std;

struct TNod;
typedef TNod *PNod;
struct TNod
{
 long val;
 long left,right,mid;
 PNod L,R;
};

long N,M;
long A[100005];
PNod Frunze[100005];

PNod T;

PNod CreazaNod(long left,long right)
{
 PNod r = new TNod;
 r->left = left;
 r->right = right;
 r->mid = left + ((right - left) >> 1);
 r->L = 0;
 r->R = 0;
 if (r->left == r->right)
   {
    r->val = left;
    Frunze[left] = r;
   }
  else
   {
    r->val = -1;
   }
 return r;
}

PNod ConstruiesteArbore(long left,long right)
{
 PNod R = CreazaNod(left,right);
 if (R->val < 0)
   {
    R->L = ConstruiesteArbore(left,R->mid);
    R->R = ConstruiesteArbore(R->mid + 1,right);
   }
 return R;
}

long ComputeMax(PNod r)
{
 if (r->val < 0)
   {
    long a,b;
    a = ComputeMax(r->L);
    b = ComputeMax(r->R);
    if (A[a] > A[b])
      {
       r->val = a;
      }
     else
      {
       r->val = b;
      }
   }
 return r->val;
}

long AflaMax(PNod r,long a,long b)
{
 if ((a == r->left) && (b == r->right))
   {
    return r->val;
   }
 if (a > r->mid)
   {
    return AflaMax(r->R,a,b);
   }
 if (b <= r->mid)
   {
    return AflaMax(r->L,a,b);
   }
 if ((r->left <= a) && (b <= r->right))
   {
    long c,d;
    c = AflaMax(r->L,a,r->mid);
    d = AflaMax(r->R,r->mid + 1,b);
    if (A[c] > A[d])
      {
       return c;
      }
     else
      {
       return d;
      }
   }
 return 0;
}

long UpdateVal(PNod r,long a)
{
 if (r->left == r->right)
   {
    return r->val;
   }
 if (a <= r->mid)
   {
    long c,d;
    c = UpdateVal(r->L,a);
    d = r->R->val;
    if (A[c] > A[d])
      {
       r->val = c;
       return c;
      }
     else
      {
       r->val = d;
       return d;
      }
   }
 if (a > r->mid)
   {
    long c,d;
    c = r->L->val;
    d = UpdateVal(r->R,a);
    if (A[c] > A[d])
      {
       r->val = c;
       return c;
      }
     else
      {
       r->val = d;
       return d;
      }
   }
 return 0;
}

int main(void)
{
 fstream fin("arbint.in",ios::in);
 fstream fout("arbint.out",ios::out);
 long i,op,a,b;
 fin >> N >> M;
 for (i = 1;i <= N;i += 1)
  {
   fin >> A[i];
  }
 T = ConstruiesteArbore(1,N);
 ComputeMax(T);
 for (i = 0;i < M;i += 1)
  {
   fin >> op >> a >> b;
   switch (op)
    {
     case 0 :
       {
        fout << A[AflaMax(T,a,b)] << "\n";
       }
      break;
     case 1 :
       {
        A[a] = b;
        UpdateVal(T,a);
       }
      break;
    };
  }
 fin.close();
 fout.close();
 return 0;
}