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.add(args[1], args[2]+1, args[3]);
    }else{
      writeln(tree.rmin(args[1], args[2]+1));
    }
  }
}

class SquareRootDecomposition{
  import std.algorithm;
  int D=1;
  int[] val, buc, laz;
  this(int n){
    while(D*D<n) D++;
    val.length=D*D;
    buc.length=laz.length=D;
  }

  void add(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_000_000_000;
    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){
    val[(k*D)..((k+1)*D)]+=laz[k];
    laz[k]=0;
  }

  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));
}
