Go: package main

// packed from [splaytree.go main.rmq.go splaytree_debug.go] with goone.

import (
	"bufio"
	"fmt"
	"io"
	"os"
	"strconv"
	"strings"
)

type SplayTreeNode struct {
	parent, left, right *SplayTreeNode

	size    int
	value   int
	minimum int
}

func newSplayTreeNode(v int) *SplayTreeNode {
	return &SplayTreeNode{value: v}
}

func (node *SplayTreeNode) rotate() {
	var pp, p, c *SplayTreeNode
	p = node.parent
	pp = p.parent
	if pp != nil && pp.left == p {
		pp.left = node
	}
	if pp != nil && pp.right == p {
		pp.right = node
	}
	node.parent = pp
	if p.left == node {
		c = node.right
		node.right = p
		p.left = c
	} else {
		c = node.left
		node.left = p
		p.right = c
	}
	p.parent = node
	if c != nil {
		c.parent = p
	}
	p.update()
	node.update()
}

func (node *SplayTreeNode) state() int {
	if node.parent == nil {
		return 0
	}
	if node.parent.left == node {
		return -1
	} else if node.parent.right == node {
		return 1
	}
	return 0
}

func (node *SplayTreeNode) splay() {
	for node.state() != 0 {
		if node.parent.state() == 0 {
			node.rotate()
			return
		}
		if node.state() == node.parent.state() {
			node.parent.rotate()
			node.rotate()
		} else {
			node.rotate()
			node.rotate()
		}
	}
}

func (node *SplayTreeNode) update() {
	node.size = 1
	node.minimum = node.value
	if node.left != nil {
		node.size += node.left.size
		node.minimum = min(node.minimum, node.left.minimum)
	}
	if node.right != nil {
		node.size += node.right.size
		node.minimum = min(node.minimum, node.right.minimum)
	}
}
func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

func (node *SplayTreeNode) Get(idx int) *SplayTreeNode {
	cur := node
	for true {
		lSize := 0
		if cur.left != nil {
			lSize = cur.left.size
		}
		if idx < lSize {
			cur = cur.left
		}
		if lSize == idx {
			cur.splay()
			return cur
		}
		if idx > lSize {
			cur = cur.right
			idx = idx - lSize - 1
		}
	}
	return nil
}

func mergeSplayNode(l, r *SplayTreeNode) (root *SplayTreeNode) {
	if l == nil {
		return r
	}
	if r == nil {
		return l
	}
	root = l.Get(l.size - 1)
	root.right = r
	r.parent = root
	root.update()
	return root
}

func (node *SplayTreeNode) Split(leftCount int) (left *SplayTreeNode, right *SplayTreeNode) {
	root := node.Get(leftCount)
	lRoot, rRoot := root.left, root

	rRoot.left = nil
	if lRoot != nil {
		lRoot.parent = nil
	}
	rRoot.update()
	return lRoot, rRoot
}

func splayTreeInsert(t *SplayTreeNode, idx int, node *SplayTreeNode) (root *SplayTreeNode) {
	l, r := t.Split(idx)
	return mergeSplayNode(
		mergeSplayNode(l, node),
		r,
	)
}

func removeSplayTree(t *SplayTreeNode, idx int) (root *SplayTreeNode, removed *SplayTreeNode) {
	target := t.Get(idx)
	l, r := target.left, target.right
	if l != nil {
		l.parent = nil
	}
	if r != nil {
		r.parent = nil
	}
	target.left = nil
	target.right = nil
	target.update()
	return mergeSplayNode(l, r), target
}

const (
	initialBufSize = 100000
	maxBufSize     = 1000000
)

var sc *bufio.Scanner

func initScanner(r io.Reader) *bufio.Scanner {
	buf := make([]byte, initialBufSize)

	sc := bufio.NewScanner(r)
	sc.Buffer(buf, maxBufSize)
	sc.Split(bufio.ScanWords)
	return sc
}

func main() {
	sc = initScanner(os.Stdin)
	resolve()
}

func resolve() {
	n := scanInt(sc)
	q := scanInt(sc)
	table := newDebugNodeSlice(200001)
	for i := 0; i < n; i++ {
		table.l[i].parent = &table.l[i+1]
		table.l[i+1].left = &table.l[i]
		table.l[i].update()
		table.l[i+1].update()
	}
	var root *SplayTreeNode = &table.l[n]
	for i := 0; i < n; i++ {
		table.l[i].value = scanInt(sc)
		table.l[i].update()
	}
	table.l[n].update()
	for i := 0; i < q; i++ {
		switch scanInt(sc) {
		case 0:
			root = shift(root, scanInt(sc), scanInt(sc))
		case 1:
			l := scanInt(sc)
			r := scanInt(sc)
			tmp, rRoot := root.Split(r + 1)
			lRoot, cRoot := tmp.Split(l)
			fmt.Println(cRoot.minimum)
			root = mergeSplayNode(mergeSplayNode(lRoot, cRoot), rRoot)
		case 2:
			root = root.Get(scanInt(sc))
			root.value = scanInt(sc)
			root.update()
		}
	}
}


C++: // includes
#include <cstdio>
#include <cstdint>
#include <iostream>
#include <iomanip>
#include <string>
#include <queue>
#include <stack>
#include <vector>
#include <set>
#include <map>
#include <unordered_map>
#include <algorithm>
#include <utility>
#include <functional>
#include <cmath>
#include <climits>
#include <bitset>
#include <list>
#include <random>

// macros
#define ll long long int
#define pb emplace_back
#define mk make_pair
#define pq priority_queue
#define FOR(i, a, b) for(int i=(a);i<(b);++i)
#define rep(i, n) FOR(i, 0, n)
#define rrep(i, n) for(int i=((int)(n)-1);i>=0;i--)
#define all(x) (x).begin(),(x).end()
#define sz(x) ((int)(x).size())
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end())

using namespace std;

//  types
typedef pair<int, int> P;
typedef pair<ll, int> Pl;
typedef pair<ll, ll> Pll;
typedef pair<double, double> Pd;
 
// constants
const int inf = 1e9;
const ll linf = 1LL << 50;
const double EPS = 1e-10;
const int mod = 1e9 + 7;

// solve
template <class T>bool chmax(T &a, const T &b){if(a < b){a = b; return 1;} return 0;}
template <class T>bool chmin(T &a, const T &b){if(a > b){a = b; return 1;} return 0;}

template <typename T, typename E>
struct ImplicitTreap{
  random_device rnd;
  T def = 0;
  E l_def = 0;
  function<T(T, T)> f;
  function<E(E, E)> g;
  function<T(T, E, int)> p;

  struct Node{
    T val, acc;
    E lazy;
    int cnt, pri;
    bool rev;
    Node *l, *r;
    Node(T val, int pri, T def, E l_def): val(val), acc(def), lazy(l_def), cnt(1), pri(pri), rev(false), l(nullptr), r(nullptr){}
  };
  using Tree = Node *;
  Tree root = nullptr;
  ImplicitTreap(T def, E l_def, function<T(T, T)> f, function<E(E, E)> g, function<T(T, E, int)> p): def(def), l_def(l_def), f(f), g(g), p(p){}
  int cnt(Tree t){
    if(!t)return 0;
    return t->cnt;
  }
  T acc(Tree t){
    if(!t)return def;
    return t->acc;
  }
  void update_cnt(Tree t){
    if(t){
      t->cnt = 1 + cnt(t->l) + cnt(t->r);
    }
  }
  void update_acc(Tree t){
    if(t){
      t->acc = f(t->val, f(acc(t->l), acc(t->r)));
    }
  }
  void pushup(Tree t){
    update_cnt(t);
    update_acc(t);
  }
  void pushdown(Tree t){
    if(t){
      if(t->rev){
        t->rev = false;
        swap(t->l, t->r);
        if(t->l)t->l->rev ^= 1;
        if(t->r)t->r->rev ^= 1;
      }
      if(t->lazy != l_def){
        if(t->l){
          t->l->lazy = g(t->l->lazy, t->lazy);
          t->l->acc = p(t->l->acc, t->lazy, cnt(t->l));
        }
        if(t->r){
          t->r->lazy = g(t->r->lazy, t->lazy);
          t->r->acc = p(t->r->acc, t->lazy, cnt(t->r));
        }
        t->val = p(t->val, t->lazy, 1);
        t->lazy = l_def;
      }
    }
    pushup(t);
  }
  void split(Tree t, int key, Tree &l, Tree &r){
    if(!t){
      l = r = nullptr;
      return;
    }
    pushdown(t);
    int ikey = cnt(t->l) + 1;
    if(key < ikey)split(t->l, key, l, t->l), r = t;
    else split(t->r, key - ikey, t->r, r), l = t;
    pushup(t);
  }
  void merge(Tree &t, Tree l, Tree r){
    pushdown(l);
    pushdown(r);
    if(!l || !r){
      if(l)t = l;
      else t = r;
      return;
    }
    if(l->pri > r->pri){
      merge(l->r, l->r, r), t = l;
    }else{
      merge(r->l, l, r->l), t = r;
    }
    pushup(t);
  }
  void insert(Tree &t, int key, Tree item){
    Tree t1, t2;
    split(t, key, t1, t2);
    merge(t1, t1, item);
    merge(t, t1, t2);
  }
  void erase(Tree &t, int key){
    Tree t1, t2, t3;
    split(t, key + 1, t1, t2);
    split(t1, key, t1, t3);
    merge(t, t1, t2);
  }
  void update(Tree t, int l, int r, E x){
    Tree t1, t2, t3;
    split(t, l, t1, t2);
    split(t2, r - l, t2, t3);
    t2->lazy = g(t2->lazy, x);
    t2->acc = p(t2->acc, x, cnt(t2));
    merge(t2, t2, t3);
    merge(t, t1, t2);
  }
  T query(Tree t, int l, int r){
    Tree t1, t2, t3;
    split(t, l, t1, t2);
    split(t2, r - l, t2, t3);
    T res = t2->acc;
    merge(t2, t2, t3);
    merge(t, t1, t2);
    return res;
  }
  int find(Tree t, T x, int of, bool left=true){
    if(f(t->acc, x) == x)return -1;
    if(left){
      if(t->l && f(t->l->acc, x) != x)return find(t->l, x, of, left);
      if(f(t->val, x) != x)return of + cnt(t->l);
      return find(t->r, x, of + cnt(t->l) + 1, left);
    }else{
      if(t->r && f(t->r->acc, x) != x)return find(t->r, x, of + cnt(t->l) + 1, left);
      if(f(t->val, x) != x)return of + cnt(t->l);
      return find(t->l, x, of, left);
    }
  }
  void reverse(Tree t, int l, int r){
    if(l > r)return;
    Tree t1, t2, t3;
    split(t, l, t1, t2);
    split(t2, r - l, t2, t3);
    t2->rev ^= 1;
    merge(t2, t2, t3);
    merge(t, t1, t2);
  }
  // m is top
  void rotate(Tree t, int l, int m, int r){
    reverse(t, l, r);
    reverse(t, l, l + r - m);
    reverse(t, l + r - m, r);
  }
  int size(){
    return cnt(root);
  }
  void insert(int pos, T x){
    insert(root, pos, new Node(x, rnd(), def, l_def));
  }
  void update(int l, int r, T x){
    update(root, l, r, x);
  }
  T query(int l, int r){
    return query(root, l, r);
  }
  int find(int l, int r, T x, bool left=true){
    Tree t1, t2, t3;
    split(root, l, t1, t2);
    split(t2, r - l, t2, t3);
    int res = find(t2, x, l, left);
    merge(t2, t2, t3);
    merge(root, t1, t2);
    return res;
  }
  void erase(int pos){
    erase(root, pos);
  }
  void reverse(int l, int r){
    reverse(root, l, r);
  }
  void rotate(int l, int m, int r){
    rotate(root, l, m, r);
  }
  T operator[](int pos){
    Tree t1, t2, t3;
    split(root, pos + 1, t1, t2);
    split(t1, pos, t1, t3);
    T res = t3->acc;
    merge(t1, t1, t3);
    merge(root, t1, t2);
    return res;
  }
};

int main(int argc, char const* argv[])
{
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  int n, q;
  cin >> n >> q;
  ImplicitTreap<ll, ll> itr(linf, linf, [](ll a, ll b){return min(a, b);},
      [](ll a, ll b){return b;}, [](ll a, ll b, int c){return b;});
  vector<ll> a(n);
  rep(i, n)cin >> a[i];
  reverse(all(a));
  rep(i, n)itr.insert(0, a[i]);
  rep(i, q){
    int x;
    cin >> x;
    if(x == 0){
      int l, r;
      cin >> l >> r, r++;
      itr.rotate(l, r - 1, r);
    }else if(x == 1){
      int l, r;
      cin >> l >> r, r++;
      cout << itr.query(l, r) << endl;
    }else{
      int pos;
      ll z;
      cin >> pos >> z;
      itr.update(pos, pos+1, z);
    }
  }
	return 0;
}