void main(){
  import std.stdio, std.string, std.conv, std.algorithm;
 
  int n, q; rd(n, q);
  auto tree=new SquareRootDecomposition(n);
  while(q--){
    auto args=readln.split.to!(int[]);
    if(args[0]==0){
      tree.update(args[1], args[2]+1, args[3]);
    }else{
      writeln(tree.rmin(args[1], args[2]+1));
    }
  }
}
 
class SquareRootDecomposition{
  import std.algorithm;
  int D=1, nil=-1;
  int[] val, buc, laz;
  this(int n){
    while(D*D<n) D++;
    val.length=D*D;
    buc.length=laz.length=D;
    fill(val, (1<<31)-1);
    fill(buc, (1<<31)-1);
    fill(laz, nil);
  }
 
  void update(int ql, int qr, int x){
    foreach(k; 0..D){
      int l=k*D, r=(k+1)*D;
      if(r<=ql || qr<=l){
        // 
      }else if(ql<=l && r<=qr){
        buc[k]=x;
        laz[k]=x;
      }else{
        push(k);
        val[max(l, ql)..min(r, qr)]=x;
        buc[k]=reduce!(min)(val[l..r]); 
      }
    }
  }
 
  int rmin(int ql, int qr){
    int ret=(1<<31)-1;
    foreach(k; 0..D){
      int l=k*D, r=(k+1)*D;
      if(r<=ql || qr<=l){
        // 
      }else if(ql<=l && r<=qr){
        chmin(ret, buc[k]);
      }else{
        push(k);
        chmin(ret, reduce!(min)(val[max(l, ql)..min(r, qr)]));
      }
    }
    return ret;
  }
 
  void push(int k){
    if(laz[k]<0) return;
    val[(k*D)..((k+1)*D)]=laz[k];
    laz[k]=-1;
  }
 
  void chmin(T)(ref T l, T r){
    if(l>r) l=r;
  }
}
 
void rd(T...)(ref T x){
  import std.stdio, std.string, std.conv;
  auto l=readln.split;
  assert(l.length==x.length);
  foreach(i, ref e; x) e=l[i].to!(typeof(e));
}
