#include <algorithm>
#include <iostream>
#include <vector>
#include <functional>
#include <utility>
using namespace std;

template <typename T, typename E>
struct LazySegmentTree{
private:
  using F = function<T(T,T)>;
  using G = function<T(T,E)>;
  using H = function<E(E,E)>;
  int n, height;
  F f;
  G g;
  H h;
  T ti;
  E ei;
  vector<T> dat;
  vector<E> laz;
  T reflect(int k){
    return laz[k] == ei ? dat[k] : g(dat[k],laz[k]);
  }
  void propagate(int k){
    if(laz[k] == ei) return;
    if(k >= n){
      dat[k] = reflect(k);
      laz[k] = ei;
      return;
    }
    laz[k<<1|0] = h(laz[k<<1|0],laz[k]);
    laz[k<<1|1] = h(laz[k<<1|1],laz[k]);
    dat[k] = reflect(k);
    laz[k] = ei;
  }
  void thrust(int k){
    for(int i = height; i >= 0; --i)
      propagate(k>>i);
  }
  void recalc(int k){
    while(k >>= 1){
      dat[k] = f(reflect(k<<1|0),reflect(k<<1|1));
    }
  }
public:
  LazySegmentTree(F f,G g, H h, T ti, E ei) :
    f(f), g(g), h(h), ti(ti), ei(ei) {}
  void build(int n_){
    n = n_;
    height = 2;
    while(n_ >>= 1) ++height;
    dat.assign(2*n,ti);
    laz.assign(2*n,ei);
  }
  void build(const vector<T> &v){
    int n_ = v.size();
    build(n_);
    for(int i = 0; i < n; ++i) dat[n+i]=v[i];
    for(int i = n-1; i >= 0; --i)
      dat[i]=f(dat[i<<1|0],dat[i<<1|1]);
  }
  void update(int l_, int r_, E x){
    if(l_ >= r_) return;
    l_ += n, r_ += n;
    thrust(l_);
    thrust(r_-1);
    for(int l = l_, r = r_;l < r; l >>= 1, r >>= 1){
      if(l&1) laz[l] = h(laz[l],x), ++l;
      if(r&1) --r, laz[r] = h(laz[r],x);
    }
    recalc(l_);
    recalc(r_-1);
  }
  // void set_val(int a, T x){
  //   thrust(a+=n);
  //   dat[a] = x;
  //   laz[a] = ei;
  //   recalc(a);
  // }
  T query(int l, int r){
    if(l >= r) return ti;
    l += n;
    r += n;
    thrust(l);
    thrust(r-1);
    T vl = ti, vr = ti;
    for(; l < r; l >>= 1, r >>= 1){
      if(l&1) vl = f(vl,reflect(l++));
      if(r&1) vr = f(reflect(--r),vr);
    }
    return f(vl,vr);
  }
  // void dump(){
  //   cerr << "dat ";
  //   for(auto e : dat) cerr << e << " ";
  //   cerr << endl;
  //   cerr << "laz ";
  //   for(auto e : laz) cerr << e << " ";
  //   cerr << endl;
  // }
};

void DSL_2_E(){
  using T = pair<long long, long long>;
  using E = long long;
  T ti(0,0);
  E ei = 0;
  function<T(T,T)> f = [](T a, T b) -> T { return {a.first+b.first,a.second+b.second};};
  function<T(T,E)> g = [](T a, E b) -> T { return {a.first+b*a.second,a.second};};
  function<E(E,E)> h = [](E a, E b) -> E { return a+b;};
  LazySegmentTree<T,E> st(f,g,h,ti,ei);
  int n, q;
  cin >> n >> q;
  vector<T> v(n,T(0,1));
  st.build(v);
  while(q--){
    int t;
    cin >> t;
    if(t){
      int i;
      cin >> i;
      cout << st.query(i-1,i).first << "\n";
    }else{
      int s, t, x;
      cin >> s >> t >> x;
      st.update(s-1,t,x);
    }
  }
}

void DSL_2_F(){
  using T = long long;
  using E = long long;
  T ti = (1LL<<31)-1;
  E ei = (1LL<<31)-1;
  function<T(T,T)> f = [](T a, T b){return min(a,b);};
  function<T(T,E)> g = [](T a, E b){return b;};
  function<E(E,E)> h = [](E a, E b){return b;};

  int n, q;
  cin >> n >> q;

  LazySegmentTree<T,E> st(f,g,h,ti,ei);
  st.build(n);

  while(q--){
    int t;
    cin >> t;
    if(t){
      int s, t;
      cin >> s >> t;
      cout << st.query(s,t+1) << endl;
    }else{
      int s, t, x;
      cin >> s >> t >> x;
      st.update(s,t+1,x);
    }
    // st.dump();
  }
}

int main(){
  DSL_2_F();
}



Measured memory_bytes: 6012