Problem: Write a program which manipulates a sequence A = {a0, a1, . . . , an−1} with the following operations:

* update(s, t, x): change as, as+1, ..., at to x.
* find(s, t): report the minimum element in as, as+1, ..., at.



Note that the initial values of ai (i = 0, 1, . . . , n−1) are 231-1.

Constraints

* 1 ≤ n ≤ 100000
* 1 ≤ q ≤ 100000
* 0 ≤ s ≤ t < n
* 0 ≤ x < 231−1

Input


n q
query1
query2
:
queryq


In the first line, n (the number of elements in A) and q (the number of queries) are given. Then, ith query queryi is given in the following format:


0 s t x


or


1 s t


The first digit represents the type of the query. '0' denotes update(s, t, x) and '1' denotes find(s, t).

Output

For each find operation, print the minimum value.

Examples

Input

3 5
0 0 1 1
0 1 2 3
0 2 2 2
1 0 2
1 1 2


Output

1
2


Input

1 3
1 0 0
0 0 0 5
1 0 0


Output

2147483647
5

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;

const long long INF = 1001001001001001001ll;

int size;
vector<long long> val;
vector<long long> lazy;

void lazy_propagate(int p) {
    if (lazy[p] != -1) {
        val[p] = lazy[p];
        if (p < size-1) {
            lazy[p*2+1] = lazy[p];
            lazy[p*2+2] = lazy[p];
        }
        lazy[p] = -1;
    }
}

void update(int wishl, int wishr, int watchl, int watchr, int k, int x) {
    if (wishr <= watchl || watchr <= wishl) {
        lazy_propagate(k);
        return;
    }
    if (wishl <= watchl && watchr <= wishr) {
        lazy[k] = x;
        lazy_propagate(k);
        return;
    }
    int mid = (watchl+watchr)/2;
    lazy_propagate(k);
    update(wishl, wishr, watchl, mid, k*2+1, x);
    update(wishl, wishr, mid, watchr, k*2+2, x);
    val[k] = min(val[k*2+1], val[k*2+2]);
}
void update(int wishl, int wishr, int x) {
    update(wishl, wishr, 0, size, 0, x);
}

long long getmin(int wishl, int wishr, int watchl, int watchr, int k) {
    if (wishr <= watchl || watchr <= wishl) {
        return INF;
    }
    if (wishl <= watchl && watchr <= wishr) {
        lazy_propagate(k);
        return val[k];
    }
    int mid = (watchl+watchr)/2;
    lazy_propagate(k);
    long long ml = getmin(wishl, wishr, watchl, mid, k*2+1);
    long long mr = getmin(wishl, wishr, mid, watchr, k*2+2);
    return min(ml, mr);
}
long long getmin(int wishl, int wishr) {
    return getmin(wishl, wishr, 0, size, 0);
}

signed main() {
    int n, q;
    cin >> n >> q;
    size = 1;
    while (size < n) size <<= 1;
    val = vector<long long>(size*2, (1ll<<31)-1);
    lazy = vector<long long>(size*2, -1);

    while (q--) {
        int type, l, r;
        cin >> type >> l >> r;
        if(type == 0) {
            int x;
            cin >> x;
            update(l, r+1, x);
        } else {
            cout << getmin(l, r+1) << endl;
        }
    }
    return 0;
}