#include <iostream>
#include <fstream>
#include <ctime>
#include <cstdlib>
#include <map>
using namespace std;

// S ID POS IDDR - split treap id at pos in id and iddr
// J IDST IDDR - join idst and iddr in idst
// Q ID PST PDR - find minimum of id's values form pst to pdr

ifstream F("trains.in");
ofstream G("trains.out");

const int infi = (1LL<<31)-1;
const int debuging = 0;
const int N = 16010;

struct treap
{
    int value,min,priority,size;
    treap *left,*right;
    treap() {}
    treap(int priority,int value,int min,int size,treap *left,treap *right)
    {
        this->priority = priority;
        this->value = value;
        this->min = min;
        this->left = left;
        this->right = right;
        this->size = size;
    }
};

treap* _null;
map<int,treap*> mp; // id->treap

treap *tree;
int n,m;

void init()
{
    srand(time(0));
    _null = new treap(0,infi,infi,0,NULL,NULL);
}

void update(treap *n)
{
    n->size = n->left->size + n->right->size + 1;
    n->min = min( n->left->min , n->right->min );
    n->min = min( n->min,n->value );
}

void rleft(treap* &z) // l->r
{
    treap* w = z->left;
    z->left = w->right;
    w->right = z;
    z = w;

    update(z->right);
    update(z);
}

void rright(treap* &w) // r->l
{
    treap* z = w->right;
    w->right = z->left;
    z->left = w;
    w = z;

    update(w->left);
    update(w);
}

void balance(treap* &n)
{
    if ( n->left->priority > n->priority )
        rleft(n);
    else
        if ( n->right->priority > n->priority )
            rright(n);
}

void insert(treap* &n,int pos,int priority,int value)
{
    if ( n == _null )
    {
        n = new treap(priority,value,value,1,_null,_null);
        return;
    }
    if ( pos <= n->left->size+1 )
        insert(n->left,pos,priority,value);
    else
        insert(n->right,pos-(n->left->size+1),priority,value);
    balance(n);
    update(n);
}

treap *aux;

void erase(treap *&t,int pos)
{
    if ( pos == t->left->size+1  )
    {
        if ( t->left == _null && t->right == _null )
        {
            aux = new treap(t->priority,t->value,infi,0,NULL,NULL);
            delete t;
            t = _null;
            return;
        }
        else if ( t->left->priority > t->right->priority )
        {
            rleft(t);
            erase(t->right,pos-(t->left->size)-1);
        }
        else
        {
            rright(t);
            erase(t->left,pos);
        }
    } else
    if ( t->left->size >= pos )
        erase(t->left,pos);
    else
        erase(t->right,pos-(t->left->size)-1);

    update(t);
}

void split(treap* &n,int pos,treap* &m)
{
    erase(n,pos);
    int pr = aux->priority , vl = aux->value;
    insert(n,pos,infi,aux->value);
    m = n->right;
    n->right = _null;
    erase(n,pos);
    insert(n,pos,pr,vl);
    aux = _null;
}

void join(treap *&n,treap *l,treap *r)
{
    n = new treap(-infi,infi,infi,l->size+r->size,l,r);
    erase(n,n->left->size+1);
}

int go(treap* &n,int pos,int l,int r)
{
    int a = (n->left->size+1);
    int v = infi;

    if ( pos < a )
        v = go(n->left,pos,l,r);
    else if ( pos > a )
        v = go(n->right,pos-a,l-a,r-a);

    if ( l <= a && a <= r ) v = min(v,n->value);

    if ( n->left != _null )
    {
        int start = 1;
        int stop = n->left->size;
        if ( l <= start && stop <= r )
            v = min(v,n->left->min);
    }
    if ( n->right != _null )
    {
        int start = n->left->size+2;
        int stop = n->size;
        if ( l <= start && stop <= r )
            v = min(v,n->right->min);
    }

    return v;
}

int query(treap* &n,int l,int r)
{
    int mini = infi;
    mini = min( mini , go(n,l,l,r) );
    mini = min( mini , go(n,r,l,r) );
    return mini;
}

void print(treap *n)
{
    if ( n == _null ) return;
    print(n->left);
    cerr<<n->value<<' ';
    //cerr<<n->priority<<' ';
    print(n->right);
}

int main()
{
    init();
    tree = _null;
    F>>n>>m;
    for (int i=1,a;i<=n;++i)
    {
        F>>a;
        insert(tree,i,rand()+1,a);
        if ( debuging ) print(tree),cerr<<'\n';
    }
    mp[0] = tree;
    for (int i=1;i<=m;++i)
    {
        char ch;
        F>>ch;
        if ( ch == 'S' )
        {
            int a,p,b;
            F>>a>>p>>b;
            treap* aux_tree = _null;
            split(mp[a],p,aux_tree);
            mp[b] = aux_tree;
            if ( debuging )
            {
                cerr<<"split"<<'\n';
                print(mp[a]); cerr<<'\n';
                print(mp[b]); cerr<<'\n';
            }
        }
        if ( ch == 'J' )
        {
            int a,b;
            F>>a>>b;
            join(mp[a],mp[a],mp[b]);
            mp[b] = _null;
            if ( debuging )
            {
                cerr<<"join"<<'\n';
                print(mp[a]); cerr<<'\n';
            }
        }
        if ( ch == 'Q' )
        {
            int a,l,r;
            F>>a>>l>>r;
            G<<query(mp[a],l,r)<<' ';
        }
    }
}