#define pragma

#ifdef pragma
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#endif // pragma

#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

#define ll long long
#define all(x) begin(x), end(x)
#define pb push_back
#define x first
#define y second
#define int long long
#define zero(two) memset(two, 0, sizeof(two))

using namespace std;
using namespace __gnu_pbds;


typedef vector<int> vi;
typedef vector<bool> vb;
typedef pair<int, int> pii;
typedef long double ld;
typedef vector<vi> matrix;
template<typename T>
using kawaii_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

const ld PI = atan2(0, -1);

void seriy() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    cout << fixed << setprecision(10);
    #if _offline
        freopen("input.txt", "r", stdin);
        freopen("output.txt", "w", stdout);
    #endif
}

const int MAXN = 3e5 + 10;
const int INF = 1e18 + 7;
const int MAXLOG = 20;
const int MOD = 998244353;
const int BASE = 47;

struct p {
    int l, r, x;
};

struct node {
    int sum, op;
};

vector<node> t;
vi kek, a, lg(MAXN);
int tt[MAXN][MAXLOG], mmn  = INF;
int n, k;

void push(int v) {
    if(t[v].op != -1) {
        t[v * 2 + 1].op = t[v].op;
        t[v * 2 + 2].op = t[v].op;
        t[v].sum = t[v].op;
        t[v].op = -1;
    }
}

int getmn(int l, int r) {
    l = kek[l];
    r = kek[r];
//    cerr << l << " " << r << " ";
    if(r - l + 1 >= n) {
//        cerr << mmn << '\n';
        return mmn;
    }
    else {
        l = (l - 1) % n;
        r = (r - 1) % n;
        if(l <= r) {
            int len = r - l + 1;
            int llg = lg[len];
            int res = min(tt[l][llg], tt[r - (1ll << llg) + 1][llg]);
//            cerr << res << '\n';
            return res;
        }
        else {
            int len = n - l;
            int llg = lg[len];
            int res = min(tt[l][llg], tt[n - (1ll << llg)][llg]);

            int len1 = r + 1;
            int llg1 = lg[len];
            int res1 = min(tt[0][llg], tt[r - (1ll << llg) + 1][llg]);
//            cerr << min(res, res1) << '\n';
            return min(res, res1);
        }
    }
}

void build(int v, int tl, int tr) {
    if(tl == tr) {
//        cerr << tl << " " << kek[tl] << '\n';
        t[v].sum = a[(kek[tl] - 1) % n];
        return;
    }
    int tm = (tl + tr) >> 1;
    build(v * 2 + 1, tl, tm);
    build(v * 2 + 2, tm + 1, tr);
    t[v].sum = getmn(tl, tr);
}

int get(int v, int tl, int tr, int l, int r) {
    push(v);
    if(tl > r || tr < l) {
        return INF;
    }
    if(tl >= l && tr <= r) {
//        cerr << tl << " " << tr << " " << t[v].sum << '\n';
        return t[v].sum;
    }
    int tm = (tl + tr) >> 1;
    int left = get(v * 2 + 1, tl, tm, l, r);
    int right = get(v * 2 + 2, tm + 1, tr, l, r);
    return min(left, right);
}

void update(int v, int tl, int tr, int l, int r, int val) {
    push(v);
    if(tl > r || tr < l) {
//        cerr << tl << " " << tr << " " << t[v].sum << '\n';
        return;
    }
    if(tl >= l && tr <= r) {
        t[v].op = val;
        push(v);
        cerr << tl << " " << tr << " " << t[v].sum << '\n';
        return;
    }
    int tm = (tl + tr) >> 1;
    update(v * 2 + 1, tl, tm, l, r, val);
    update(v * 2 + 2, tm + 1, tr, l, r, val);
    t[v].sum = min(t[v * 2 + 1].sum, t[v * 2 + 2].sum);
    cerr << tl << " " << tr << " " << t[v].sum << '\n';
}

signed main() {
    seriy();

    cin >> n >> k;
    a.resize(n);
    for(int i = 0; i < n; i++) {
        cin >> a[i];
        mmn = min(mmn, a[i]);
        tt[i][0] = a[i];
    }
    lg[1] = 0;
    for(int i = 2; i < MAXN; i++) {
        lg[i] = lg[i - 1];
        if((i & (i - 1)) > 0) {
            lg[i]++;
        }
    }


    for(int i = 1; i < MAXLOG; i++) {
        for(int j = 0; j < n; j++) {
            if(j + (1ll << i) <= n) tt[j][i] = min(tt[j][i - 1], tt[j + (1ll << (i - 1))][i - 1]);
            else tt[j][i] = -1;
        }
    }


    int q;
    cin >> q;
    vector<p> rq;
    for(int i = 0; i < q; i++) {
        int tp;
        cin >> tp;
        if(tp == 1) {
            int l, r, x;
            cin >> l >> r >> x;
            rq.pb({l, r, x});
            kek.pb(l);
            kek.pb(r);
        }
        else {
            int l, r;
            cin >> l >> r;
            kek.pb(l);
            kek.pb(r);
            rq.pb({l, r, -1});
        }
    }
    sort(all(kek));
    kek.resize(unique(all(kek)) - kek.begin());
    t.resize(8 * kek.size(), {INF, -1});
    build(0, 0, kek.size() - 1);
    for(int i = 0; i < q; i++) {
        if(rq[i].x == -1) {
            int left = lower_bound(all(kek), rq[i].l) - kek.begin();
            int right = lower_bound(all(kek), rq[i].r) - kek.begin();
            cout << get(0, 0, kek.size() - 1, left, right) << '\n';
        }
        else {
            int left = lower_bound(all(kek), rq[i].l) - kek.begin();
            int right = lower_bound(all(kek), rq[i].r) - kek.begin();
            update(0, 0, kek.size() - 1, left, right, rq[i].x);
        }
    }
    return 0;
}