#include <bits/stdc++.h>
using namespace std;
#define int long long
using ll=long long;
using vi=vector<int>;
using vl=vector<long long>;
using pii=pair<int,int>;
using pll=pair<long long,long long>;
#define ITR(i,c) for(auto i=begin(c);i!=end(c);++i)
#define FORE(x,c) for(auto &x:c)
#define REPF(i,a,n) for(int i=a,i##len=(int)(n);i<i##len;++i)
#define REP(i,n) REPF(i,0,n)
#define REPR(i,n) for(int i=(int)(n);i>=0;--i)
#define REPW(i,n) for(i=0;i<(int)(n);++i)
#define ALL(c) begin(c),end(c)
#define RALL(c) rbegin(c),rend(c)
#define SZ(c) ((int)c.size())
#define CONTAIN(c,x) (c.find(x)!=end(c))
#define OUTOFRANGE(y,x,h,w) (y<0||x<0||y>=h||x>=w)
#define dump(...)
const int DX[9]={0,1,0,-1,1,1,-1,-1,0},DY[9]={-1,0,1,0,-1,1,1,-1,0};
#define INF (1001001001)
#define INFLL (1001001001001001001ll)
template<class T> ostream& operator << (ostream &os,const vector<T> &v) {
    ITR(i,v) os << *i << (i==end(v)-1 ? "" : " "); return os; }
template<class T> istream& operator >> (istream &is,vector<T> &v) {
    ITR(i,v) is >> *i; return is; }
template<class T> istream& operator >> (istream &is, pair<T,T> &p) {
        is >> p.first >> " " >> p.second; return is; }
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(b<a){a=b;return 1;}return 0;}
//------------------------------------------------------------------------------
struct before_main_function {
    before_main_function() {
        #ifdef int
            #undef INF
            #define INF INFLL
            #define stoi stoll
        #endif
        cin.tie(0);ios::sync_with_stdio(false);
        cout<<setprecision(15)<<fixed;
    }
} before_main_function;
//------------------8<------------------------------------8<--------------------

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

void lazy_propagate(int p) {
    if(lazy[p]<0) return;
    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]);
}

int 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);
    int ml=getmin(wishl,wishr,watchl,mid,k*2+1);
    int mr=getmin(wishl,wishr,mid,watchr,k*2+2);
    return min(ml,mr);
}

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

    width=vector<int>(2*size,1);
    REPR(i,size-2) {
        width[i]=width[i*2+1]+width[i*2+2];
    }

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

Measured memory_bytes: 8904