/**************************************************************

    Problem:

    User: BLADEVIL

    Language: Pascal

    Result: Accepted

    Time: ms

    Memory: kb

****************************************************************/

//By BLADEVIL

type

    rec                     =record

        left, right, root   :longint;

    end;

var

    n, m                    :longint;

    a                       :array[..] of longint;

    t                       :array[..] of rec;

    bt                      :array[..] of longint;

    b_size, b_left, b_right :array[..] of longint;

    b_key                   :array[..] of longint;

    tot                     :longint;

function min(a,b:longint):longint;

begin

    if a>b then min:=b else min:=a;

end;

function max(a,b:longint):longint;

begin

    if a>b then max:=a else max:=b;

end;

procedure rotate_right(var t:longint);

var

    k                       :longint;

begin

    k:=b_left[t];

    b_left[t]:=b_right[k];

    b_right[k]:=t;

    b_size[k]:=b_size[t];

    b_size[t]:=b_size[b_right[t]]+b_size[b_left[t]]+;

    t:=k;

end;

procedure rotate_left(var t:longint);

var

    k                       :longint;

begin

    k:=b_right[t];

    b_right[t]:=b_left[k];

    b_left[k]:=t;

    b_size[k]:=b_size[t];

    b_size[t]:=b_size[b_right[t]]+b_size[b_left[t]]+;

    t:=k;

end;

procedure maintain(var t:longint; flag:boolean);

begin

    if not flag then

    begin

        if b_size[b_left[b_left[t]]]>b_size[b_right[t]] then

            rotate_right(b_left[t]) else

        if b_size[b_right[b_left[t]]]>b_size[b_right[t]] then

        begin

            rotate_left(b_left[t]);

            rotate_right(t);

        end else exit;

    end else

    begin

        if b_size[b_right[b_right[t]]]>b_size[b_left[t]] then

            rotate_left(b_right[t]) else

        if b_size[b_left[b_right[t]]]>b_size[b_left[t]] then

        begin

            rotate_right(b_right[t]);

            rotate_left(t);

        end else exit;

    end;

    maintain(b_left[t],false);

    maintain(b_right[t],true);

    maintain(t,true);

    maintain(t,false);

end;

procedure insert(var t:longint; v:longint);

begin

    if t= then

    begin

        inc(tot);

        t:=tot;

        b_left[t]:=;

        b_right[t]:=;

        b_size[t]:=;

        b_key[t]:=v;

    end else

    begin

        inc(b_size[t]);

        if v>=b_key[t] then

            insert(b_right[t],v) else

            insert(b_left[t],v);

        maintain(t,v>=b_key[t]);

    end;

end;

function delete(var t:longint; v:longint):longint;

begin

    dec(b_size[t]);

    if (b_key[t]=v)

        or (b_right[t]=) and (v>b_key[t])

        or (b_left[t]=) and (v<b_key[t]) then

    begin

        delete:=b_key[t];

        if (b_left[t]=) or (b_right[t]=) then

            t:=b_right[t]+b_left[t] else

                b_key[t]:=delete(b_left[t],v+);

    end else

        if v<b_key[t] then delete:=delete(b_left[t],v) else

            delete:=delete(b_right[t],v);

end;

function rank(var t:longint; v:longint):longint;

begin

    if t= then exit();

    if v<=b_key[t] then rank:=rank(b_left[t],v) else

        rank:=rank(b_right[t],v)+b_size[b_left[t]]+;

end;

procedure build(x,l,r:longint);

var

    mid                     :longint;

    i                       :longint;

begin

    t[x].left:=l; t[x].right:=r;

    t[x].root:=;

    for i:=l to r do insert(t[x].root,a[i]);

    if l=r then exit;

    mid:=(l+r) div ;

    build(x*,l,mid); build(x*+,mid+,r);

end;

procedure change(x,y,z:longint);

var

    mid                     :longint;

begin

    mid:=delete(t[x].root,a[y]);

    insert(t[x].root,z);

    if t[x].left=t[x].right then exit;

    with t[x] do mid:=(left+right) div ;

    if y>mid then change(x*+,y,z) else change(x*,y,z);

end;

function ask(x,l,r,k:longint):longint;

var

    mid                     :longint;

begin

    ask:=;

    if (t[x].left=l) and (t[x].right=r) then

    begin

        ask:=rank(t[x].root,k);

        exit;

    end;

    with t[x] do mid:=(left+right) div ;

    if mid<l then ask:=ask(x*+,l,r,k) else

    if mid>=r then ask:=ask(x*,l,r,k) else

    ask:=ask(x*,l,mid,k)+ask(x*+,mid+,r,k);

end;

function succ(var t:longint;v:longint):longint;

begin

    if t= then exit(-);

    if b_key[t]<v then succ:=succ(b_right[t],v) else

    begin

        succ:=succ(b_left[t],v);

        if succ=- then succ:=b_key[t];

    end;

end;

function pred(var t:longint;v:longint):longint;

begin

    if t= then exit(-);

    if b_key[t]>v then pred:=pred(b_left[t],v) else

    begin

        pred:=pred(b_right[t],v);

        if pred=- then pred:=b_key[t];

    end;

end;

function ask_succ(x,l,r,y:longint):longint;

var

    mid                     :longint;

begin

    if (t[x].left=l) and (t[x].right=r) then

    begin

        ask_succ:=succ(t[x].root,y);

        if ask_succ=- then ask_succ:=maxlongint;

        exit;

    end;

    with t[x] do mid:=(left+right) div ;

    if l>mid then ask_succ:=ask_succ(x*+,l,r,y) else

    if r<=mid then ask_succ:=ask_succ(x*,l,r,y) else

    ask_succ:=min(ask_succ(x*,l,mid,y),ask_succ(x*+,mid+,r,y));

end;

function ask_pred(x,l,r,y:longint):longint;

var

    mid                     :longint;

begin

    if (t[x].left=l) and (t[x].right=r) then

    begin

        ask_pred:=pred(t[x].root,y);

        exit;

    end;

    with t[x] do mid:=(left+right) div ;

    if l>mid then ask_pred:=ask_pred(x*+,l,r,y) else

    if r<=mid then ask_pred:=ask_pred(x*,l,r,y) else

    ask_pred:=max(ask_pred(x*,l,mid,y),ask_pred(x*+,mid+,r,y));

end;

procedure query(x,y,k:longint);

var

    l, r, mid               :longint;

    ans                     :longint;

    xx                      :longint;

begin

    l:=; r:=;

    while l<=r do

    begin

        mid:=(l+r) div ;

        xx:=ask(,x,y,mid);

        if xx>=k- then

        begin

            ans:=mid;

            r:=mid-;

        end else l:=mid+;

    end;

    if ask(,x,y,ans)<>k- then

        xx:=ask_pred(,x,y,ans-) else

        xx:=ask_succ(,x,y,ans);

    writeln(xx);

end;

procedure init;

var

    i                       :longint;

begin

    read(n,m);

    for i:= to n do read(a[i]);

    readln;

    build(,,n);

end;

procedure main;

var

    i                       :longint;

    ch                      :char;

    l, r, x                 :longint;

begin

    for i:= to m do

    begin

        read(ch);

        if ch='Q' then

        begin

            readln(l,r,x);

            query(l,r,x);

        end else

        begin

            readln(l,x);

            change(,l,x);

            a[l]:=x;

        end;

    end;

end;

begin

    init;

    main;

end.