#include<bits/stdc++.h>
using namespace std;
using Int = long long;
template<typename T1,typename T2> inline void chmin(T1 &a,T2 b){if(a>b) a=b;}
template<typename T1,typename T2> inline void chmax(T1 &a,T2 b){if(a<b) a=b;}

//INSERT ABOVE HERE
#define int long long

const int INF = 1e15;

struct Node{
  int fst,num,snd,cnt,sum;
  Node(){}
  Node(int fst,int num,int snd,int cnt,int sum):
    fst(fst),num(num),snd(snd),cnt(cnt),sum(sum){}
};
Node node_identity(INF,0,INF,0,0);

Node node_mg(Node a,Node b){
  Node c;
  c.fst=min(a.fst,b.fst);
  c.num=0;
  if(c.fst==a.fst) c.num+=a.num;
  if(c.fst==b.fst) c.num+=b.num;
  c.snd=INF;
  for(int x:{a.fst,a.snd,b.fst,b.snd})
    if(x!=c.fst) chmin(c.snd,x);
  if(c.snd==INF) c.snd=c.fst;
  c.cnt=a.cnt+b.cnt;
  c.sum=a.sum+b.sum;
  return c;
};

struct Op{
  int chm,add;
  Op(){}
  Op(int chm,int add):chm(chm),add(add){}
};
Op op_identity(-INF,0);

Op op_mg(Op a,Op b){
  return Op(max(a.chm,b.chm-a.add),a.add+b.add);
}

Node operate(Node a,Op b){
  if(a.fst==a.snd){
    assert(a.num==a.cnt);
    int val=max(a.fst,b.chm)+b.add;
    return Node(val,a.num,val,a.cnt,val*a.cnt);
  }
  if(a.fst<b.chm){
    assert(b.chm<a.snd);
    a.sum+=(b.chm-a.fst)*a.num;
    a.fst=b.chm;
  }
  a.fst+=b.add;
  a.snd+=b.add;
  a.sum+=a.cnt*b.add;
  return a;
}

bool appliable(Node a,Op b){
  if(a.fst==a.snd) return true;
  if(b.chm< a.snd) return true;
  return false;
}

bool break_condition(Node a,Op b){
  return (b.add==0&&b.chm<=a.fst);
}

struct SegmentTree{
  int n;
  vector<Node> dat;
  vector<Op> laz;
  SegmentTree(vector<int> cs){
    int n_=cs.size();
    n=1;
    while(n<n_) n<<=1;
    dat.assign(n<<1,node_identity);
    laz.assign(n<<1,op_identity);
    for(int i=0;i<n_;i++)
      dat[n+i]=Node(cs[i],1,cs[i],1,cs[i]);
    for(int i=n-1;i>=0;i--)
      dat[i]=node_mg(dat[(i<<1)|0],dat[(i<<1)|1]);
  }

  bool check(int k){
    return appliable(dat[k],laz[k]);
  }

  Node reflect(int k){
    assert(check(k));
    return operate(dat[k],laz[k]);
  }

  void eval(int k){
    if(k<n){
      laz[(k<<1)|0]=op_mg(laz[(k<<1)|0],laz[k]);
      laz[(k<<1)|1]=op_mg(laz[(k<<1)|1],laz[k]);
    }
    dat[k]=reflect(k);
    laz[k]=op_identity;
  }

  void update(int a,int b,Op x,int k,int l,int r){
    eval(k);
    if(r<=a||b<=l||break_condition(dat[k],x)) return;
    if(a<=l&&r<=b){
      laz[k]=x;
      if(check(k)) return;
      laz[k]=op_identity;
    }
    int m=(l+r)>>1;
    update(a,b,x,(k<<1)|0,l,m);
    update(a,b,x,(k<<1)|1,m,r);
    dat[k]=node_mg(reflect((k<<1)|0),reflect((k<<1)|1));
  }

  void update_add(int a,int b,int x){
    update(a,b,Op(-INF,x),1,0,n);
  }

  void update_chm(int a,int b,int x){
    update(a,b,Op(x,0),1,0,n);
  }

  int query(int a,int b,int k,int l,int r){
    eval(k);
    if(r<=a||b<=l) return 0;
    if(a<=l&&r<=b) return dat[k].sum;
    int m=(l+r)>>1;
    return query(a,b,(k<<1)|0,l,m)+query(a,b,(k<<1)|1,m,r);
  }

  int query(int a,int b){
    return query(a,b,1,0,n);
  }
};

signed main(){
  cin.tie(0);
  ios::sync_with_stdio(0);

  int n;
  cin>>n;
  vector<int> cs(n);
  for(int i=0;i<n;i++) cin>>cs[i];
  SegmentTree seg(cs);

  int q;
  cin>>q;
  for(int i=0;i<q;i++){
    int t;
    cin>>t;
    if(t==1){
      int a,b,d;
      cin>>a>>b>>d;
      a--;
      seg.update_add(a,b,+d);
      seg.update_chm(a,b,0);
    }
    if(t==2){
      int a,b,d;
      cin>>a>>b>>d;
      a--;
      int before=seg.query(a,b);
      seg.update_add(a,b,-d);
      seg.update_chm(a,b,0);
      int after=seg.query(a,b);
      cout<<before-after<<"\n";
    }
    cout<<flush;
  }
  return 0;
}



Measured memory_bytes: 18728