#include <cstdio>
#include <vector>
#include <cstring>
#include <functional>
#include <algorithm>
#include <math.h>
#include <bitset>
#include <set>
#include <queue>
#include <iostream>
#include <string>
#include <sstream>
#include <stack>
#include <complex>
#include <numeric>
#include <map>
#include <time.h>
using namespace std;
typedef long double ld;
typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int uint;
typedef pair<int,int> pii;
typedef pair<int,ll> pil;
typedef pair<ll,int> pli;
typedef pair<ll,ll> pll;
typedef pair<pii,ll> ppl;
typedef pair<ll,pii> plp;
typedef pair<int,pii> pip;
typedef pair<pii,int> ppi;
typedef pair<pii,pii> ppp;
typedef pair<double,int> pdi;
typedef pair<double,pii> pdp;
typedef pair<double,double> pdd;
typedef pair<pdd,double> pd3;
typedef vector<double> vec;
typedef vector<vec> mat;
#define rep(i,n) for (int (i) = 0; (i) < (n); (i)++)
#define repn(i,a,n) for (int (i) = (a); (i) < (n); (i)++)
#define ALL(x) (x).begin(),(x).end()
#define pb push_back
#define SORT(x) sort((x).begin(),(x).end())
#define SORTN(x,n) sort((x),(x)+(n))
#define ERASE(x) (x).erase(unique((x).begin(),(x).end()),(x).end())
#define COUNT(x,c) count((x).begin(),(x).end(),(c))
#define REMOVE(x,c) (x).erase(remove((x).begin(),(x).end(),(c)),(x).end())
#define REVERSE(x) reverse((x).begin(),(x).end())
#define FORIT(it,v) for(__typeof((v).begin()) it=(v).begin();it!=(v).end();it++)
#define LB(x,a) lower_bound((x).begin(),(x).end(),(a))-(x).begin()
#define lb(x,a) lower_bound((x).begin(),(x).end(),(a))
#define LBN(x,a,n) lower_bound((x),(x)+(n),(a))-(x)
#define lbN(x,a,n) lower_bound((x),(x)+(n),(a))
#define UB(x,a) upper_bound((x).begin(),(x).end(),(a))-(x).begin()
#define ub(x,a) upper_bound((x).begin(),(x).end(),(a))
#define BS(x,a) binary_search((x).begin(),(x).end(),(a))
#define BS2(x,n,a) binary_search((x),(x)+(n),(a))
#define NB(x) (((x)&~((x)+((x)&-(x))))/((x)&-(x))>>1)|((x)+((x)&-(x)))
#define NP(x) next_permutation((x).begin(),(x).end())
#define MM(x,p) memset((x),(p),sizeof(x))
#define SQ(x) (x)*(x)
#define SC(c1,c2) strcmp(c1,c2)==0
#define mp make_pair
#define INF (1<<30)
#define INFL (1LL<<61)
#define fi first
#define se second
#define MOD 1000000007
#define EPS 1e-12
#define MIN(x,a) x=min(x,a)
#define MAX(x,a) x=max(x,a)
#define madd(x,a) x=(x+a)%MOD
#define msub(x,a) x=(x+MOD-a)%MOD
#define OUTPUT(x) rep(i,x.size())printf("%d%c",x[i],i+1==x.size()?'\n':' ');

int Q,P,V,L,R,K;
const int n=1<<18;
int A[n];

struct Query
{
    pip lma,rma,lmi,rmi,sum,ma,mi;
};
pip con(pip p1,pip p2)
{
    return mp(p1.fi+p2.fi,mp(p1.se.fi,p2.se.se));
}
Query unite(Query q1,Query q2)
{
    if(q1.sum.fi==INF)return q2;
    if(q2.sum.fi==INF)return q1;
    Query res;
    res.lma=max(q1.lma,con(q1.sum,q2.lma));
    res.rma=max(q2.rma,con(q1.rma,q2.sum));
    res.lmi=min(q1.lmi,con(q1.sum,q2.lmi));
    res.rmi=min(q2.rmi,con(q1.rmi,q2.sum));
    res.ma=max(max(q1.ma,q2.ma),con(q1.rma,q2.lma));
    res.mi=min(max(q1.mi,q2.mi),con(q1.rmi,q2.lmi));
    res.sum=con(q1.sum,q2.sum);
    return res;
}
Query invq(Query q)
{
    Query res;
    res.lmi=q.lma,res.rmi=q.rma,res.lma=q.lmi,res.rma=q.rmi,res.sum=q.sum,res.ma=q.mi,res.mi=q.ma;
    res.lmi.fi*=-1,res.rmi.fi*=-1,res.lma.fi*=-1,res.rma.fi*=-1,res.sum.fi*=-1,res.ma.fi*=-1,res.mi.fi*=-1;
    return res;
}
bool invf[n*2-1];
Query dat[n*2-1];
void seg_update(int i,int v)
{
    vector<int> ls;
    int tmp=i;
    while(tmp)tmp=(tmp-1)/2,ls.pb(tmp);
    for(int ai=ls.size()-1;ai>=0;ai--)
    {
        int k=ls[ai];
        if(invf[k])
        {
            invf[k]=false;;
            invf[k*2+1]=invf[k*2+2]=true;
            dat[k*2+1]=invq(dat[k*2+1]);
            dat[k*2+2]=invq(dat[k*2+2]);
        }
    }
    A[i]=v;
    if(A[i]>=0)
    {
        dat[i+n-1].lma=mp(A[i],mp(i,i+1));
        dat[i+n-1].rma=mp(A[i],mp(i,i+1));
        dat[i+n-1].ma=mp(A[i],mp(i,i+1));
        dat[i+n-1].lmi=mp(0,mp(i,i));
        dat[i+n-1].rmi=mp(0,mp(i+1,i+1));
        dat[i+n-1].mi=mp(0,mp(i,i));
    }
    else
    {
        dat[i+n-1].lmi=mp(A[i],mp(i,i+1));
        dat[i+n-1].rmi=mp(A[i],mp(i,i+1));
        dat[i+n-1].mi=mp(A[i],mp(i,i+1));
        dat[i+n-1].lma=mp(0,mp(i,i));
        dat[i+n-1].rma=mp(0,mp(i+1,i+1));
        dat[i+n-1].ma=mp(0,mp(i,i));
    }
    dat[i+n-1].sum=mp(A[i],mp(i,i+1));
    invf[i+n-1]=false;
    i+=n-1;
    while(i)
    {
        i=(i-1)/2;
        dat[i]=unite(dat[i*2+1],dat[i*2+2]);
    }
}
void inv(int a,int b,int k,int l,int r)
{
    if(r<=a||b<=l)return;
    if(a<=l&&r<=b)
    {
        invf[k]=!invf[k];
        dat[k]=invq(dat[k]);
        return;
    }
    if(invf[k])
    {
        invf[k]=false;
        dat[k*2+1]=invq(dat[k*2+1]);
        dat[k*2+2]=invq(dat[k*2+2]);
        invf[k*2+1]=!invf[k*2+1];
        invf[k*2+2]=!invf[k*2+2];
    }
    inv(a,b,k*2+1,l,(l+r)/2);
    inv(a,b,k*2+2,(l+r)/2,r);
    dat[k]=unite(dat[k*2+1],dat[k*2+2]);
}
Query calc(int a,int b,int k,int l,int r)
{
    if(r<=a||b<=l)
    {
        Query res;
        res.sum.fi=INF;
        return res;
    }
    if(a<=l&&r<=b)return dat[k];
    if(invf[k])
    {
        invf[k]=false;
        dat[k*2+1]=invq(dat[k*2+1]);
        dat[k*2+2]=invq(dat[k*2+2]);
        invf[k*2+1]=!invf[k*2+1];
        invf[k*2+2]=!invf[k*2+2];
    }
    return unite(calc(a,b,k*2+1,l,(l+r)/2),calc(a,b,k*2+2,(l+r)/2,r));
}

int main()
{
    scanf("%d",&Q);
    rep(i,Q)scanf("%d",&A[i]);
    scanf("%d",&Q);
    rep(i,n)
    {
        if(A[i]>=0)
        {
            dat[i+n-1].lma=mp(A[i],mp(i,i+1));
            dat[i+n-1].rma=mp(A[i],mp(i,i+1));
            dat[i+n-1].ma=mp(A[i],mp(i,i+1));
            dat[i+n-1].lmi=mp(0,mp(i,i));
            dat[i+n-1].rmi=mp(0,mp(i+1,i+1));
            dat[i+n-1].mi=mp(0,mp(i,i));
        }
        else
        {
            dat[i+n-1].lmi=mp(A[i],mp(i,i+1));
            dat[i+n-1].rmi=mp(A[i],mp(i,i+1));
            dat[i+n-1].mi=mp(A[i],mp(i,i+1));
            dat[i+n-1].lma=mp(0,mp(i,i));
            dat[i+n-1].rma=mp(0,mp(i+1,i+1));
            dat[i+n-1].ma=mp(0,mp(i,i));
        }
        dat[i+n-1].sum=mp(A[i],mp(i,i+1));
    }
    for(int i=n-2;i>=0;i--)dat[i]=unite(dat[i*2+1],dat[i*2+2]);
    while(Q--)
    {
        scanf("%d",&V);
        if(V==0)
        {
            scanf("%d%d",&P,&V);P--;
            seg_update(P,V);
        }
        else
        {
            scanf("%d%d%d",&L,&R,&K),L--;
            Query res=calc(L,R,0,0,n);
            int ans=res.ma.fi;
            vector<pii> iv;
            int tt=ans;
            rep(i,K-1)
            {
                iv.pb(res.ma.se);
                inv(res.ma.se.fi,res.ma.se.se,0,0,n);
                res=calc(L,R,0,0,n);
                MAX(ans,tt+res.ma.fi);
                tt+=res.ma.fi;
            }
            rep(i,K-1)inv(iv[i].fi,iv[i].se,0,0,n);
            printf("%d\n",ans);
        }
    }
}


#include <cstdio>
#include <vector>
#include <cstring>
#include <functional>
#include <algorithm>
#include <math.h>
#include <bitset>
#include <set>
#include <queue>
#include <iostream>
#include <string>
#include <sstream>
#include <stack>
#include <complex>
#include <numeric>
#include <map>
#include <time.h>
using namespace std;
typedef long double ld;
typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int uint;
typedef pair<int,int> pii;
typedef pair<int,ll> pil;
typedef pair<ll,int> pli;
typedef pair<ll,ll> pll;
typedef pair<pii,ll> ppl;
typedef pair<ll,pii> plp;
typedef pair<int,pii> pip;
typedef pair<pii,int> ppi;
typedef pair<pii,pii> ppp;
typedef pair<double,int> pdi;
typedef pair<double,pii> pdp;
typedef pair<double,double> pdd;
typedef pair<pdd,double> pd3;
typedef vector<double> vec;
typedef vector<vec> mat;
#define rep(i,n) for (int (i) = 0; (i) < (n); (i)++)
#define repn(i,a,n) for (int (i) = (a); (i) < (n); (i)++)
#define ALL(x) (x).begin(),(x).end()
#define pb push_back
#define SORT(x) sort((x).begin(),(x).end())
#define SORTN(x,n) sort((x),(x)+(n))
#define ERASE(x) (x).erase(unique((x).begin(),(x).end()),(x).end())
#define COUNT(x,c) count((x).begin(),(x).end(),(c))
#define REMOVE(x,c) (x).erase(remove((x).begin(),(x).end(),(c)),(x).end())
#define REVERSE(x) reverse((x).begin(),(x).end())
#define FORIT(it,v) for(__typeof((v).begin()) it=(v).begin();it!=(v).end();it++)
#define LB(x,a) lower_bound((x).begin(),(x).end(),(a))-(x).begin()
#define lb(x,a) lower_bound((x).begin(),(x).end(),(a))
#define LBN(x,a,n) lower_bound((x),(x)+(n),(a))-(x)
#define lbN(x,a,n) lower_bound((x),(x)+(n),(a))
#define UB(x,a) upper_bound((x).begin(),(x).end(),(a))-(x).begin()
#define ub(x,a) upper_bound((x).begin(),(x).end(),(a))
#define BS(x,a) binary_search((x).begin(),(x).end(),(a))
#define BS2(x,n,a) binary_search((x),(x)+(n),(a))
#define NB(x) (((x)&~((x)+((x)&-(x))))/((x)&-(x))>>1)|((x)+((x)&-(x)))
#define NP(x) next_permutation((x).begin(),(x).end())
#define MM(x,p) memset((x),(p),sizeof(x))
#define SQ(x) (x)*(x)
#define SC(c1,c2) strcmp(c1,c2)==0
#define mp make_pair
#define INF (1<<30)
#define INFL (1LL<<61)
#define fi first
#define se second
#define MOD 1000000007
#define EPS 1e-12
#define MIN(x,a) x=min(x,a)
#define MAX(x,a) x=max(x,a)
#define madd(x,a) x=(x+a)%MOD
#define msub(x,a) x=(x+MOD-a)%MOD
#define OUTPUT(x) rep(i,x.size())printf("%d%c",x[i],i+1==x.size()?'\n':' ');

int Q,P,V,L,R,K;
const int n=1<<17;
int A[n];

struct Query
{
    pip lma,rma,lmi,rmi,sum,ma,mi;
};
pip con(pip p1,pip p2)
{
    return mp(p1.fi+p2.fi,mp(p1.se.fi,p2.se.se));
}
Query unite(Query q1,Query q2)
{
    if(q1.sum.fi==INF)return q2;
    if(q2.sum.fi==INF)return q1;
    Query res;
    res.lma=max(q1.lma,con(q1.sum,q2.lma));
    res.rma=max(q2.rma,con(q1.rma,q2.sum));
    res.lmi=min(q1.lmi,con(q1.sum,q2.lmi));
    res.rmi=min(q2.rmi,con(q1.rmi,q2.sum));
    res.ma=max(max(q1.ma,q2.ma),con(q1.rma,q2.lma));
    res.mi=min(max(q1.mi,q2.mi),con(q1.rmi,q2.lmi));
    res.sum=con(q1.sum,q2.sum);
    return res;
}
Query invq(Query q)
{
    Query res;
    res.lmi=q.lma,res.rmi=q.rma,res.lma=q.lmi,res.rma=q.rmi,res.sum=q.sum,res.ma=q.mi,res.mi=q.ma;
    res.lmi.fi*=-1,res.rmi.fi*=-1,res.lma.fi*=-1,res.rma.fi*=-1,res.sum.fi*=-1,res.ma.fi*=-1,res.mi.fi*=-1;
    return res;
}
bool invf[n*2-1];
Query dat[n*2-1];
void seg_update(int i,int v)
{
    vector<int> ls;
    int tmp=i;
    while(tmp)tmp=(tmp-1)/2,ls.pb(tmp);
    for(int ai=ls.size()-1;ai>=0;ai--)
    {
        int k=ls[ai];
        if(invf[k])
        {
            invf[k]=false;;
            invf[k*2+1]=invf[k*2+2]=true;
            dat[k*2+1]=invq(dat[k*2+1]);
            dat[k*2+2]=invq(dat[k*2+2]);
    dat[k]=unite(dat[k*2+1],dat[k*2+2]);
        }
    }
    A[i]=v;
    if(A[i]>=0)
    {
        dat[i+n-1].lma=mp(A[i],mp(i,i+1));
        dat[i+n-1].rma=mp(A[i],mp(i,i+1));
        dat[i+n-1].ma=mp(A[i],mp(i,i+1));
        dat[i+n-1].lmi=mp(0,mp(i,i));
        dat[i+n-1].rmi=mp(0,mp(i,i));
        dat[i+n-1].mi=mp(0,mp(i,i));
    }
    else
    {
        dat[i+n-1].lmi=mp(A[i],mp(i,i+1));
        dat[i+n-1].rmi=mp(A[i],mp(i,i+1));
        dat[i+n-1].mi=mp(A[i],mp(i,i+1));
        dat[i+n-1].lma=mp(0,mp(i,i));
        dat[i+n-1].rma=mp(0,mp(i,i));
        dat[i+n-1].ma=mp(0,mp(i,i));
    }
    dat[i+n-1].sum=mp(A[i],mp(i,i+1));
    invf[i+n-1]=false;
    i+=n-1;
    while(i)
    {
        i=(i-1)/2;
        dat[i]=unite(dat[i*2+1],dat[i*2+2]);
    }
}
void inv(int a,int b,int k,int l,int r)
{
    if(r<=a||b<=l)return;
    if(a<=l&&r<=b)
    {
        invf[k]=!invf[k];
        dat[k]=invq(dat[k]);
        return;
    }
    if(invf[k])
    {
        invf[k]=false;
        dat[k*2+1]=invq(dat[k*2+1]);
        dat[k*2+2]=invq(dat[k*2+2]);
        invf[k*2+1]=!invf[k*2+1];
        invf[k*2+2]=!invf[k*2+2];
    dat[k]=unite(dat[k*2+1],dat[k*2+2]);
    }
    inv(a,b,k*2+1,l,(l+r)/2);
    inv(a,b,k*2+2,(l+r)/2,r);
    dat[k]=unite(dat[k*2+1],dat[k*2+2]);
}
Query calc(int a,int b,int k,int l,int r)
{
    if(r<=a||b<=l)
    {
        Query res;
        res.sum.fi=INF;
        return res;
    }
    if(a<=l&&r<=b)return dat[k];
    if(invf[k])
    {
        invf[k]=false;
        dat[k*2+1]=invq(dat[k*2+1]);
        dat[k*2+2]=invq(dat[k*2+2]);
        invf[k*2+1]=!invf[k*2+1];
        invf[k*2+2]=!invf[k*2+2];
    dat[k]=unite(dat[k*2+1],dat[k*2+2]);
    }
    return unite(calc(a,b,k*2+1,l,(l+r)/2),calc(a,b,k*2+2,(l+r)/2,r));
}

int main()
{
    scanf("%d",&Q);
    rep(i,Q)scanf("%d",&A[i]);
    scanf("%d",&Q);
    rep(i,n)
    {
        if(A[i]>=0)
        {
            dat[i+n-1].lma=mp(A[i],mp(i,i+1));
            dat[i+n-1].rma=mp(A[i],mp(i,i+1));
            dat[i+n-1].ma=mp(A[i],mp(i,i+1));
            dat[i+n-1].lmi=mp(0,mp(i,i));
            dat[i+n-1].rmi=mp(0,mp(i,i));
            dat[i+n-1].mi=mp(0,mp(i,i));
        }
        else
        {
            dat[i+n-1].lmi=mp(A[i],mp(i,i+1));
            dat[i+n-1].rmi=mp(A[i],mp(i,i+1));
            dat[i+n-1].mi=mp(A[i],mp(i,i+1));
            dat[i+n-1].lma=mp(0,mp(i,i));
            dat[i+n-1].rma=mp(0,mp(i,i));
            dat[i+n-1].ma=mp(0,mp(i,i));
        }
        dat[i+n-1].sum=mp(A[i],mp(i,i+1));
    }
    for(int i=n-2;i>=0;i--)dat[i]=unite(dat[i*2+1],dat[i*2+2]);
    while(Q--)
    {
        scanf("%d",&V);
        if(V==0)
        {
            scanf("%d%d",&P,&V);P--;
            seg_update(P,V);
        }
        else
        {
            scanf("%d%d%d",&L,&R,&K),L--;
            Query res=calc(L,R,0,0,n);
            int ans=res.ma.fi;
            vector<pii> iv;
            int tt=ans;
            rep(i,K-1)
            {
                iv.pb(res.ma.se);
                inv(res.ma.se.fi,res.ma.se.se,0,0,n);
                res=calc(L,R,0,0,n);
                MAX(ans,tt+res.ma.fi);
                tt+=res.ma.fi;
            }
            rep(i,K-1)inv(iv[i].fi,iv[i].se,0,0,n);
            printf("%d\n",ans);
        }
    }
}


#include <cstdio>
#include <vector>
#include <cstring>
#include <functional>
#include <algorithm>
#include <math.h>
#include <bitset>
#include <set>
#include <queue>
#include <iostream>
#include <string>
#include <sstream>
#include <stack>
#include <complex>
#include <numeric>
#include <map>
#include <time.h>
using namespace std;
typedef long double ld;
typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int uint;
typedef pair<int,int> pii;
typedef pair<int,ll> pil;
typedef pair<ll,int> pli;
typedef pair<ll,ll> pll;
typedef pair<pii,ll> ppl;
typedef pair<ll,pii> plp;
typedef pair<int,pii> pip;
typedef pair<pii,int> ppi;
typedef pair<pii,pii> ppp;
typedef pair<double,int> pdi;
typedef pair<double,pii> pdp;
typedef pair<double,double> pdd;
typedef pair<pdd,double> pd3;
typedef vector<double> vec;
typedef vector<vec> mat;
#define rep(i,n) for (int (i) = 0; (i) < (n); (i)++)
#define repn(i,a,n) for (int (i) = (a); (i) < (n); (i)++)
#define ALL(x) (x).begin(),(x).end()
#define pb push_back
#define SORT(x) sort((x).begin(),(x).end())
#define SORTN(x,n) sort((x),(x)+(n))
#define ERASE(x) (x).erase(unique((x).begin(),(x).end()),(x).end())
#define COUNT(x,c) count((x).begin(),(x).end(),(c))
#define REMOVE(x,c) (x).erase(remove((x).begin(),(x).end(),(c)),(x).end())
#define REVERSE(x) reverse((x).begin(),(x).end())
#define FORIT(it,v) for(__typeof((v).begin()) it=(v).begin();it!=(v).end();it++)
#define LB(x,a) lower_bound((x).begin(),(x).end(),(a))-(x).begin()
#define lb(x,a) lower_bound((x).begin(),(x).end(),(a))
#define LBN(x,a,n) lower_bound((x),(x)+(n),(a))-(x)
#define lbN(x,a,n) lower_bound((x),(x)+(n),(a))
#define UB(x,a) upper_bound((x).begin(),(x).end(),(a))-(x).begin()
#define ub(x,a) upper_bound((x).begin(),(x).end(),(a))
#define BS(x,a) binary_search((x).begin(),(x).end(),(a))
#define BS2(x,n,a) binary_search((x),(x)+(n),(a))
#define NB(x) (((x)&~((x)+((x)&-(x))))/((x)&-(x))>>1)|((x)+((x)&-(x)))
#define NP(x) next_permutation((x).begin(),(x).end())
#define MM(x,p) memset((x),(p),sizeof(x))
#define SQ(x) (x)*(x)
#define SC(c1,c2) strcmp(c1,c2)==0
#define mp make_pair
#define INF (1<<30)
#define INFL (1LL<<61)
#define fi first
#define se second
#define MOD 1000000007
#define EPS 1e-12
#define MIN(x,a) x=min(x,a)
#define MAX(x,a) x=max(x,a)
#define madd(x,a) x=(x+a)%MOD
#define msub(x,a) x=(x+MOD-a)%MOD
#define OUTPUT(x) rep(i,x.size())printf("%d%c",x[i],i+1==x.size()?'\n':' ');

int Q,P,V,L,R,K;
const int n=1<<18;
int A[n];

struct Query
{
    pip lma,rma,lmi,rmi,sum,ma,mi;
};
pip con(pip p1,pip p2)
{
    return mp(p1.fi+p2.fi,mp(p1.se.fi,p2.se.se));
}
Query unite(Query q1,Query q2)
{
    if(q1.sum.fi==INF)return q2;
    if(q2.sum.fi==INF)return q1;
    Query res;
    res.lma=max(q1.lma,con(q1.sum,q2.lma));
    res.rma=max(q2.rma,con(q1.rma,q2.sum));
    res.lmi=min(q1.lmi,con(q1.sum,q2.lmi));
    res.rmi=min(q2.rmi,con(q1.rmi,q2.sum));
    res.ma=max(max(q1.ma,q2.ma),con(q1.rma,q2.lma));
    res.mi=min(min(q1.mi,q2.mi),con(q1.rmi,q2.lmi));
    res.sum=con(q1.sum,q2.sum);
    return res;
}
Query invq(Query q)
{
    Query res;
    res.lmi=q.lma,res.rmi=q.rma,res.lma=q.lmi,res.rma=q.rmi,res.sum=q.sum,res.ma=q.mi,res.mi=q.ma;
    res.lmi.fi*=-1,res.rmi.fi*=-1,res.lma.fi*=-1,res.rma.fi*=-1,res.sum.fi*=-1,res.ma.fi*=-1,res.mi.fi*=-1;
    return res;
}
bool invf[n*2-1];
Query dat[n*2-1];
void seg_update(int i,int v)
{
    vector<int> ls;
    int tmp=i;
    while(tmp)tmp=(tmp-1)/2,ls.pb(tmp);
    for(int ai=ls.size()-1;ai>=0;ai--)
    {
        int k=ls[ai];
        if(invf[k])
        {
            invf[k]=false;;
            invf[k*2+1]=!invf[k*2+1];
            invf[k*2+2]=!invf[k*2+2];
            dat[k*2+1]=invq(dat[k*2+1]);
            dat[k*2+2]=invq(dat[k*2+2]);
        }
    }
    A[i]=v;
    if(A[i]>=0)
    {
        dat[i+n-1].lma=mp(A[i],mp(i,i+1));
        dat[i+n-1].rma=mp(A[i],mp(i,i+1));
        dat[i+n-1].ma=mp(A[i],mp(i,i+1));
        dat[i+n-1].lmi=mp(0,mp(i,i));
        dat[i+n-1].rmi=mp(0,mp(i+1,i+1));
        dat[i+n-1].mi=mp(0,mp(i,i));
    }
    else
    {
        dat[i+n-1].lmi=mp(A[i],mp(i,i+1));
        dat[i+n-1].rmi=mp(A[i],mp(i,i+1));
        dat[i+n-1].mi=mp(A[i],mp(i,i+1));
        dat[i+n-1].lma=mp(0,mp(i,i));
        dat[i+n-1].rma=mp(0,mp(i+1,i+1));
        dat[i+n-1].ma=mp(0,mp(i,i));
    }
    dat[i+n-1].sum=mp(A[i],mp(i,i+1));
    invf[i+n-1]=false;
    i+=n-1;
    while(i)
    {
        i=(i-1)/2;
        dat[i]=unite(dat[i*2+1],dat[i*2+2]);
    }
}
void inv(int a,int b,int k,int l,int r)
{
    if(r<=a||b<=l)return;
    if(a<=l&&r<=b)
    {
        invf[k]=!invf[k];
        dat[k]=invq(dat[k]);
        return;
    }
    if(invf[k])
    {
        invf[k]=false;
        dat[k*2+1]=invq(dat[k*2+1]);
        dat[k*2+2]=invq(dat[k*2+2]);
        invf[k*2+1]=!invf[k*2+1];
        invf[k*2+2]=!invf[k*2+2];
    }
    inv(a,b,k*2+1,l,(l+r)/2);
    inv(a,b,k*2+2,(l+r)/2,r);
    dat[k]=unite(dat[k*2+1],dat[k*2+2]);
}
Query calc(int a,int b,int k,int l,int r)
{
    if(r<=a||b<=l)
    {
        Query res;
        res.sum.fi=INF;
        return res;
    }
    if(a<=l&&r<=b)return dat[k];
    if(invf[k])
    {
        invf[k]=false;
        dat[k*2+1]=invq(dat[k*2+1]);
        dat[k*2+2]=invq(dat[k*2+2]);
        invf[k*2+1]=!invf[k*2+1];
        invf[k*2+2]=!invf[k*2+2];
    }
    return unite(calc(a,b,k*2+1,l,(l+r)/2),calc(a,b,k*2+2,(l+r)/2,r));
}

int main()
{
    scanf("%d",&Q);
    rep(i,Q)scanf("%d",&A[i]);
    scanf("%d",&Q);
    rep(i,n)
    {
        if(A[i]>=0)
        {
            dat[i+n-1].lma=mp(A[i],mp(i,i+1));
            dat[i+n-1].rma=mp(A[i],mp(i,i+1));
            dat[i+n-1].ma=mp(A[i],mp(i,i+1));
            dat[i+n-1].lmi=mp(0,mp(i,i));
            dat[i+n-1].rmi=mp(0,mp(i+1,i+1));
            dat[i+n-1].mi=mp(0,mp(i,i));
        }
        else
        {
            dat[i+n-1].lmi=mp(A[i],mp(i,i+1));
            dat[i+n-1].rmi=mp(A[i],mp(i,i+1));
            dat[i+n-1].mi=mp(A[i],mp(i,i+1));
            dat[i+n-1].lma=mp(0,mp(i,i));
            dat[i+n-1].rma=mp(0,mp(i+1,i+1));
            dat[i+n-1].ma=mp(0,mp(i,i));
        }
        dat[i+n-1].sum=mp(A[i],mp(i,i+1));
    }
    for(int i=n-2;i>=0;i--)dat[i]=unite(dat[i*2+1],dat[i*2+2]);
    while(Q--)
    {
        scanf("%d",&V);
        if(V==0)
        {
            scanf("%d%d",&P,&V);P--;
            seg_update(P,V);
        }
        else
        {
            scanf("%d%d%d",&L,&R,&K),L--;
            Query res=calc(L,R,0,0,n);
            int ans=res.ma.fi;
            vector<pii> iv;
            int tt=ans;
            rep(i,K-1)
            {
                if(res.ma.fi==0)break;
                iv.pb(res.ma.se);
                inv(res.ma.se.fi,res.ma.se.se,0,0,n);
                res=calc(L,R,0,0,n);

                MAX(ans,tt+res.ma.fi);
                tt+=res.ma.fi;
            }
            rep(i,iv.size())inv(iv[i].fi,iv[i].se,0,0,n);
            printf("%d\n",ans);
        }
    }
}


#include <cstdio>
#include <vector>
#include <cstring>
#include <functional>
#include <algorithm>
#include <math.h>
#include <bitset>
#include <set>
#include <queue>
#include <iostream>
#include <string>
#include <sstream>
#include <stack>
#include <complex>
#include <numeric>
#include <map>
#include <time.h>
using namespace std;
typedef long double ld;
typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int uint;
typedef pair<int,int> pii;
typedef pair<int,ll> pil;
typedef pair<ll,int> pli;
typedef pair<ll,ll> pll;
typedef pair<pii,ll> ppl;
typedef pair<ll,pii> plp;
typedef pair<int,pii> pip;
typedef pair<pii,int> ppi;
typedef pair<pii,pii> ppp;
typedef pair<double,int> pdi;
typedef pair<double,pii> pdp;
typedef pair<double,double> pdd;
typedef pair<pdd,double> pd3;
typedef vector<double> vec;
typedef vector<vec> mat;
#define rep(i,n) for (int (i) = 0; (i) < (n); (i)++)
#define repn(i,a,n) for (int (i) = (a); (i) < (n); (i)++)
#define ALL(x) (x).begin(),(x).end()
#define pb push_back
#define SORT(x) sort((x).begin(),(x).end())
#define SORTN(x,n) sort((x),(x)+(n))
#define ERASE(x) (x).erase(unique((x).begin(),(x).end()),(x).end())
#define COUNT(x,c) count((x).begin(),(x).end(),(c))
#define REMOVE(x,c) (x).erase(remove((x).begin(),(x).end(),(c)),(x).end())
#define REVERSE(x) reverse((x).begin(),(x).end())
#define FORIT(it,v) for(__typeof((v).begin()) it=(v).begin();it!=(v).end();it++)
#define LB(x,a) lower_bound((x).begin(),(x).end(),(a))-(x).begin()
#define lb(x,a) lower_bound((x).begin(),(x).end(),(a))
#define LBN(x,a,n) lower_bound((x),(x)+(n),(a))-(x)
#define lbN(x,a,n) lower_bound((x),(x)+(n),(a))
#define UB(x,a) upper_bound((x).begin(),(x).end(),(a))-(x).begin()
#define ub(x,a) upper_bound((x).begin(),(x).end(),(a))
#define BS(x,a) binary_search((x).begin(),(x).end(),(a))
#define BS2(x,n,a) binary_search((x),(x)+(n),(a))
#define NB(x) (((x)&~((x)+((x)&-(x))))/((x)&-(x))>>1)|((x)+((x)&-(x)))
#define NP(x) next_permutation((x).begin(),(x).end())
#define MM(x,p) memset((x),(p),sizeof(x))
#define SQ(x) (x)*(x)
#define SC(c1,c2) strcmp(c1,c2)==0
#define mp make_pair
#define INF (1<<30)
#define INFL (1LL<<61)
#define fi first
#define se second
#define MOD 1000000007
#define EPS 1e-12
#define MIN(x,a) x=min(x,a)
#define MAX(x,a) x=max(x,a)
#define madd(x,a) x=(x+a)%MOD
#define msub(x,a) x=(x+MOD-a)%MOD
#define OUTPUT(x) rep(i,x.size())printf("%d%c",x[i],i+1==x.size()?'\n':' ');

int Q,P,V,L,R,K;
const int n=1<<17;
int A[n];

struct Query
{
	pip lma,rma,lmi,rmi,sum,ma,mi;
};
pip con(pip p1,pip p2)
{
	return mp(p1.fi+p2.fi,mp(p1.se.fi,p2.se.se));
}
Query unite(Query q1,Query q2)
{
	if(q1.sum.fi==INF)return q2;
	if(q2.sum.fi==INF)return q1;
	Query res;
	res.lma=max(q1.lma,con(q1.sum,q2.lma));
	res.rma=max(q2.rma,con(q1.rma,q2.sum));
	res.lmi=min(q1.lmi,con(q1.sum,q2.lmi));
	res.rmi=min(q2.rmi,con(q1.rmi,q2.sum));
	res.ma=max(max(q1.ma,q2.ma),con(q1.rma,q2.lma));
	res.mi=min(max(q1.mi,q2.mi),con(q1.rmi,q2.lmi));
	res.sum=con(q1.sum,q2.sum);
	return res;
}
Query invq(Query q)
{
	Query res;
	res.lmi=q.lma,res.rmi=q.rma,res.lma=q.lmi,res.rma=q.rmi,res.sum=q.sum,res.ma=q.mi,res.mi=q.ma;
	res.lmi.fi*=-1,res.rmi.fi*=-1,res.lma.fi*=-1,res.rma.fi*=-1,res.sum.fi*=-1,res.ma.fi*=-1,res.mi.fi*=-1;
	return res;
}
bool invf[n*2-1];
Query dat[n*2-1];
void seg_update(int i,int v)
{
	vector<int> ls;
	int tmp=i;
	while(tmp)tmp=(tmp-1)/2,ls.pb(tmp);
	for(int ai=ls.size()-1;ai>=0;ai--)
	{
		int k=ls[ai];
		if(invf[k])
		{
			invf[k]=false;;
			invf[k*2+1]=invf[k*2+2]=true;
			dat[k*2+1]=invq(dat[k*2+1]);
			dat[k*2+2]=invq(dat[k*2+2]);
		}
	}
	A[i]=v;
	if(A[i]>=0)
	{
		dat[i+n-1].lma=mp(A[i],mp(i,i+1));
		dat[i+n-1].rma=mp(A[i],mp(i,i+1));
		dat[i+n-1].ma=mp(A[i],mp(i,i+1));
		dat[i+n-1].lmi=mp(0,mp(i,i));
		dat[i+n-1].rmi=mp(0,mp(i+1,i+1));
		dat[i+n-1].mi=mp(0,mp(i,i));
	}
	else
	{
		dat[i+n-1].lmi=mp(A[i],mp(i,i+1));
		dat[i+n-1].rmi=mp(A[i],mp(i,i+1));
		dat[i+n-1].mi=mp(A[i],mp(i,i+1));
		dat[i+n-1].lma=mp(0,mp(i,i));
		dat[i+n-1].rma=mp(0,mp(i+1,i+1));
		dat[i+n-1].ma=mp(0,mp(i,i));
	}
	dat[i+n-1].sum=mp(A[i],mp(i,i+1));
	invf[i+n-1]=false;
	i+=n-1;
	while(i)
	{
		i=(i-1)/2;
		dat[i]=unite(dat[i*2+1],dat[i*2+2]);
	}
}
void inv(int a,int b,int k,int l,int r)
{
	if(r<=a||b<=l)return;
	if(a<=l&&r<=b)
	{
		invf[k]=!invf[k];
		dat[k]=invq(dat[k]);
		return;
	}
	if(invf[k])
	{
		invf[k]=false;
		dat[k*2+1]=invq(dat[k*2+1]);
		dat[k*2+2]=invq(dat[k*2+2]);
		invf[k*2+1]=!invf[k*2+1];
		invf[k*2+2]=!invf[k*2+2];
	}
	inv(a,b,k*2+1,l,(l+r)/2);
	inv(a,b,k*2+2,(l+r)/2,r);
	dat[k]=unite(dat[k*2+1],dat[k*2+2]);
}
Query calc(int a,int b,int k,int l,int r)
{
	if(r<=a||b<=l)
	{
		Query res;
		res.sum.fi=INF;
		return res;
	}
	if(a<=l&&r<=b)return dat[k];
	if(invf[k])
	{
		invf[k]=false;
		dat[k*2+1]=invq(dat[k*2+1]);
		dat[k*2+2]=invq(dat[k*2+2]);
		invf[k*2+1]=!invf[k*2+1];
		invf[k*2+2]=!invf[k*2+2];
	}
	return unite(calc(a,b,k*2+1,l,(l+r)/2),calc(a,b,k*2+2,(l+r)/2,r));
}

int main()
{
	scanf("%d",&Q);
	rep(i,Q)scanf("%d",&A[i]);
	scanf("%d",&Q);
	rep(i,n)
	{
		if(A[i]>=0)
		{
			dat[i+n-1].lma=mp(A[i],mp(i,i+1));
			dat[i+n-1].rma=mp(A[i],mp(i,i+1));
			dat[i+n-1].ma=mp(A[i],mp(i,i+1));
			dat[i+n-1].lmi=mp(0,mp(i,i));
			dat[i+n-1].rmi=mp(0,mp(i+1,i+1));
			dat[i+n-1].mi=mp(0,mp(i,i));
		}
		else
		{
			dat[i+n-1].lmi=mp(A[i],mp(i,i+1));
			dat[i+n-1].rmi=mp(A[i],mp(i,i+1));
			dat[i+n-1].mi=mp(A[i],mp(i,i+1));
			dat[i+n-1].lma=mp(0,mp(i,i));
			dat[i+n-1].rma=mp(0,mp(i+1,i+1));
			dat[i+n-1].ma=mp(0,mp(i,i));
		}
		dat[i+n-1].sum=mp(A[i],mp(i,i+1));
	}
	for(int i=n-2;i>=0;i--)dat[i]=unite(dat[i*2+1],dat[i*2+2]);
	while(Q--)
	{
		scanf("%d",&V);
		if(V==0)
		{
			scanf("%d%d",&P,&V);P--;
			seg_update(P,V);
		}
		else
		{
			scanf("%d%d%d",&L,&R,&K),L--;
			Query res=calc(L,R,0,0,n);
			int ans=res.ma.fi;
			vector<pii> iv;
			int tt=ans;
			rep(i,K-1)
			{
				iv.pb(res.ma.se);
				inv(res.ma.se.fi,res.ma.se.se,0,0,n);
				res=calc(L,R,0,0,n);
				MAX(ans,tt+res.ma.fi);
				tt+=res.ma.fi;
			}
			rep(i,K-1)inv(iv[i].fi,iv[i].se,0,0,n);
			printf("%d\n",ans);
		}
	}
}


#include <cstdio>
#include <vector>
#include <cstring>
#include <functional>
#include <algorithm>
#include <math.h>
#include <bitset>
#include <set>
#include <queue>
#include <iostream>
#include <string>
#include <sstream>
#include <stack>
#include <complex>
#include <numeric>
#include <map>
#include <time.h>
using namespace std;
typedef long double ld;
typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int uint;
typedef pair<int,int> pii;
typedef pair<int,ll> pil;
typedef pair<ll,int> pli;
typedef pair<ll,ll> pll;
typedef pair<pii,ll> ppl;
typedef pair<ll,pii> plp;
typedef pair<int,pii> pip;
typedef pair<pii,int> ppi;
typedef pair<pii,pii> ppp;
typedef pair<double,int> pdi;
typedef pair<double,pii> pdp;
typedef pair<double,double> pdd;
typedef pair<pdd,double> pd3;
typedef vector<double> vec;
typedef vector<vec> mat;
#define rep(i,n) for (int (i) = 0; (i) < (n); (i)++)
#define repn(i,a,n) for (int (i) = (a); (i) < (n); (i)++)
#define ALL(x) (x).begin(),(x).end()
#define pb push_back
#define SORT(x) sort((x).begin(),(x).end())
#define SORTN(x,n) sort((x),(x)+(n))
#define ERASE(x) (x).erase(unique((x).begin(),(x).end()),(x).end())
#define COUNT(x,c) count((x).begin(),(x).end(),(c))
#define REMOVE(x,c) (x).erase(remove((x).begin(),(x).end(),(c)),(x).end())
#define REVERSE(x) reverse((x).begin(),(x).end())
#define FORIT(it,v) for(__typeof((v).begin()) it=(v).begin();it!=(v).end();it++)
#define LB(x,a) lower_bound((x).begin(),(x).end(),(a))-(x).begin()
#define lb(x,a) lower_bound((x).begin(),(x).end(),(a))
#define LBN(x,a,n) lower_bound((x),(x)+(n),(a))-(x)
#define lbN(x,a,n) lower_bound((x),(x)+(n),(a))
#define UB(x,a) upper_bound((x).begin(),(x).end(),(a))-(x).begin()
#define ub(x,a) upper_bound((x).begin(),(x).end(),(a))
#define BS(x,a) binary_search((x).begin(),(x).end(),(a))
#define BS2(x,n,a) binary_search((x),(x)+(n),(a))
#define NB(x) (((x)&~((x)+((x)&-(x))))/((x)&-(x))>>1)|((x)+((x)&-(x)))
#define NP(x) next_permutation((x).begin(),(x).end())
#define MM(x,p) memset((x),(p),sizeof(x))
#define SQ(x) (x)*(x)
#define SC(c1,c2) strcmp(c1,c2)==0
#define mp make_pair
#define INF (1<<30)
#define INFL (1LL<<61)
#define fi first
#define se second
#define MOD 1000000007
#define EPS 1e-12
#define MIN(x,a) x=min(x,a)
#define MAX(x,a) x=max(x,a)
#define madd(x,a) x=(x+a)%MOD
#define msub(x,a) x=(x+MOD-a)%MOD
#define OUTPUT(x) rep(i,x.size())printf("%d%c",x[i],i+1==x.size()?'\n':' ');

int Q,P,V,L,R,K;
const int n=1<<17;
int A[n];

struct Query
{
	pip lma,rma,lmi,rmi,sum,ma,mi;
};
pip con(pip p1,pip p2)
{
	return mp(p1.fi+p2.fi,mp(p1.se.fi,p2.se.se));
}
Query unite(Query q1,Query q2)
{
	if(q1.sum.fi==INF)return q2;
	if(q2.sum.fi==INF)return q1;
	Query res;
	res.lma=max(q1.lma,con(q1.sum,q2.lma));
	res.rma=max(q2.rma,con(q1.rma,q2.sum));
	res.lmi=min(q1.lmi,con(q1.sum,q2.lmi));
	res.rmi=min(q2.rmi,con(q1.rmi,q2.sum));
	res.ma=max(max(q1.ma,q2.ma),con(q1.rma,q2.lma));
	res.mi=min(max(q1.mi,q2.mi),con(q1.rmi,q2.lmi));
	res.sum=con(q1.sum,q2.sum);
	return res;
}
Query invq(Query q)
{
	Query res;
	res.lmi=q.lma,res.rmi=q.rma,res.lma=q.lmi,res.rma=q.rmi,res.sum=q.sum,res.ma=q.mi,res.mi=q.ma;
	res.lmi.fi*=-1,res.rmi.fi*=-1,res.lma.fi*=-1,res.rma.fi*=-1,res.sum.fi*=-1,res.ma.fi*=-1,res.mi.fi*=-1;
	return res;
}
bool invf[n*2-1];
Query dat[n*2-1];
void seg_update(int i,int v)
{
	vector<int> ls;
	int tmp=i;
	while(tmp)tmp=(tmp-1)/2,ls.pb(tmp);
	for(int ai=ls.size()-1;ai>=0;ai--)
	{
		int k=ls[ai];
		if(invf[k])
		{
			invf[k]=false;;
			invf[k*2+1]=invf[k*2+2]=true;
			dat[k*2+1]=invq(dat[k*2+1]);
			dat[k*2+2]=invq(dat[k*2+2]);
		}
	}
	A[i]=v;
	if(A[i]>=0)
	{
		dat[i+n-1].lma=mp(A[i],mp(i,i+1));
		dat[i+n-1].rma=mp(A[i],mp(i,i+1));
		dat[i+n-1].ma=mp(A[i],mp(i,i+1));
		dat[i+n-1].lmi=mp(0,mp(i,i));
		dat[i+n-1].rmi=mp(0,mp(i,i));
		dat[i+n-1].mi=mp(0,mp(i,i));
	}
	else
	{
		dat[i+n-1].lmi=mp(A[i],mp(i,i+1));
		dat[i+n-1].rmi=mp(A[i],mp(i,i+1));
		dat[i+n-1].mi=mp(A[i],mp(i,i+1));
		dat[i+n-1].lma=mp(0,mp(i,i));
		dat[i+n-1].rma=mp(0,mp(i,i));
		dat[i+n-1].ma=mp(0,mp(i,i));
	}
	dat[i+n-1].sum=mp(A[i],mp(i,i+1));
	invf[i+n-1]=false;
	i+=n-1;
	while(i)
	{
		i=(i-1)/2;
		dat[i]=unite(dat[i*2+1],dat[i*2+2]);
	}
}
void inv(int a,int b,int k,int l,int r)
{
	if(r<=a||b<=l)return;
	if(a<=l&&r<=b)
	{
		invf[k]=!invf[k];
		dat[k]=invq(dat[k]);
		return;
	}
	if(invf[k])
	{
		invf[k]=false;
		dat[k*2+1]=invq(dat[k*2+1]);
		dat[k*2+2]=invq(dat[k*2+2]);
		invf[k*2+1]=!invf[k*2+1];
		invf[k*2+2]=!invf[k*2+2];
	}
	inv(a,b,k*2+1,l,(l+r)/2);
	inv(a,b,k*2+2,(l+r)/2,r);
	dat[k]=unite(dat[k*2+1],dat[k*2+2]);
}
Query calc(int a,int b,int k,int l,int r)
{
	if(r<=a||b<=l)
	{
		Query res;
		res.sum.fi=INF;
		return res;
	}
	if(a<=l&&r<=b)return dat[k];
	if(invf[k])
	{
		invf[k]=false;
		dat[k*2+1]=invq(dat[k*2+1]);
		dat[k*2+2]=invq(dat[k*2+2]);
		invf[k*2+1]=!invf[k*2+1];
		invf[k*2+2]=!invf[k*2+2];
	}
	return unite(calc(a,b,k*2+1,l,(l+r)/2),calc(a,b,k*2+2,(l+r)/2,r));
}

int main()
{
	scanf("%d",&Q);
	rep(i,Q)scanf("%d",&A[i]);
	scanf("%d",&Q);
	rep(i,n)
	{
		if(A[i]>=0)
		{
			dat[i+n-1].lma=mp(A[i],mp(i,i+1));
			dat[i+n-1].rma=mp(A[i],mp(i,i+1));
			dat[i+n-1].ma=mp(A[i],mp(i,i+1));
			dat[i+n-1].lmi=mp(0,mp(i,i));
			dat[i+n-1].rmi=mp(0,mp(i,i));
			dat[i+n-1].mi=mp(0,mp(i,i));
		}
		else
		{
			dat[i+n-1].lmi=mp(A[i],mp(i,i+1));
			dat[i+n-1].rmi=mp(A[i],mp(i,i+1));
			dat[i+n-1].mi=mp(A[i],mp(i,i+1));
			dat[i+n-1].lma=mp(0,mp(i,i));
			dat[i+n-1].rma=mp(0,mp(i,i));
			dat[i+n-1].ma=mp(0,mp(i,i));
		}
		dat[i+n-1].sum=mp(A[i],mp(i,i+1));
	}
	for(int i=n-2;i>=0;i--)dat[i]=unite(dat[i*2+1],dat[i*2+2]);
	while(Q--)
	{
		scanf("%d",&V);
		if(V==0)
		{
			scanf("%d%d",&P,&V);P--;
			seg_update(P,V);
		}
		else
		{
			scanf("%d%d%d",&L,&R,&K),L--;
			Query res=calc(L,R,0,0,n);
			int ans=res.ma.fi;
			vector<pii> iv;
			int tt=ans;
			rep(i,K-1)
			{
				iv.pb(res.ma.se);
				inv(res.ma.se.fi,res.ma.se.se,0,0,n);
				res=calc(L,R,0,0,n);
				MAX(ans,tt+res.ma.fi);
				tt+=res.ma.fi;
			}
			rep(i,K-1)inv(iv[i].fi,iv[i].se,0,0,n);
			printf("%d\n",ans);
		}
	}
}


#include <cstdio>
#include <vector>
#include <cstring>
#include <functional>
#include <algorithm>
#include <math.h>
#include <bitset>
#include <set>
#include <queue>
#include <iostream>
#include <string>
#include <sstream>
#include <stack>
#include <complex>
#include <numeric>
#include <map>
#include <time.h>
using namespace std;
typedef long double ld;
typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int uint;
typedef pair<int,int> pii;
typedef pair<int,ll> pil;
typedef pair<ll,int> pli;
typedef pair<ll,ll> pll;
typedef pair<pii,ll> ppl;
typedef pair<ll,pii> plp;
typedef pair<int,pii> pip;
typedef pair<pii,int> ppi;
typedef pair<pii,pii> ppp;
typedef pair<double,int> pdi;
typedef pair<double,pii> pdp;
typedef pair<double,double> pdd;
typedef pair<pdd,double> pd3;
typedef vector<double> vec;
typedef vector<vec> mat;
#define rep(i,n) for (int (i) = 0; (i) < (n); (i)++)
#define repn(i,a,n) for (int (i) = (a); (i) < (n); (i)++)
#define ALL(x) (x).begin(),(x).end()
#define pb push_back
#define SORT(x) sort((x).begin(),(x).end())
#define SORTN(x,n) sort((x),(x)+(n))
#define ERASE(x) (x).erase(unique((x).begin(),(x).end()),(x).end())
#define COUNT(x,c) count((x).begin(),(x).end(),(c))
#define REMOVE(x,c) (x).erase(remove((x).begin(),(x).end(),(c)),(x).end())
#define REVERSE(x) reverse((x).begin(),(x).end())
#define FORIT(it,v) for(__typeof((v).begin()) it=(v).begin();it!=(v).end();it++)
#define LB(x,a) lower_bound((x).begin(),(x).end(),(a))-(x).begin()
#define lb(x,a) lower_bound((x).begin(),(x).end(),(a))
#define LBN(x,a,n) lower_bound((x),(x)+(n),(a))-(x)
#define lbN(x,a,n) lower_bound((x),(x)+(n),(a))
#define UB(x,a) upper_bound((x).begin(),(x).end(),(a))-(x).begin()
#define ub(x,a) upper_bound((x).begin(),(x).end(),(a))
#define BS(x,a) binary_search((x).begin(),(x).end(),(a))
#define BS2(x,n,a) binary_search((x),(x)+(n),(a))
#define NB(x) (((x)&~((x)+((x)&-(x))))/((x)&-(x))>>1)|((x)+((x)&-(x)))
#define NP(x) next_permutation((x).begin(),(x).end())
#define MM(x,p) memset((x),(p),sizeof(x))
#define SQ(x) (x)*(x)
#define SC(c1,c2) strcmp(c1,c2)==0
#define mp make_pair
#define INF (1<<30)
#define INFL (1LL<<61)
#define fi first
#define se second
#define MOD 1000000007
#define EPS 1e-12
#define MIN(x,a) x=min(x,a)
#define MAX(x,a) x=max(x,a)
#define madd(x,a) x=(x+a)%MOD
#define msub(x,a) x=(x+MOD-a)%MOD
#define OUTPUT(x) rep(i,x.size())printf("%d%c",x[i],i+1==x.size()?'\n':' ');

int Q,P,V,L,R,K;
const int n=1<<18;
int A[n];

struct Query
{
    pip lma,rma,lmi,rmi,sum,ma,mi;
};
pip con(pip p1,pip p2)
{
    return mp(p1.fi+p2.fi,mp(p1.se.fi,p2.se.se));
}
Query unite(Query q1,Query q2)
{
    if(q1.sum.fi==INF)return q2;
    if(q2.sum.fi==INF)return q1;
    Query res;
    res.lma=max(q1.lma,con(q1.sum,q2.lma));
    res.rma=max(q2.rma,con(q1.rma,q2.sum));
    res.lmi=min(q1.lmi,con(q1.sum,q2.lmi));
    res.rmi=min(q2.rmi,con(q1.rmi,q2.sum));
    res.ma=max(max(q1.ma,q2.ma),con(q1.rma,q2.lma));
    res.mi=min(max(q1.mi,q2.mi),con(q1.rmi,q2.lmi));
    res.sum=con(q1.sum,q2.sum);
    return res;
}
Query invq(Query q)
{
    Query res;
    res.lmi=q.lma,res.rmi=q.rma,res.lma=q.lmi,res.rma=q.rmi,res.sum=q.sum,res.ma=q.mi,res.mi=q.ma;
    res.lmi.fi*=-1,res.rmi.fi*=-1,res.lma.fi*=-1,res.rma.fi*=-1,res.sum.fi*=-1,res.ma.fi*=-1,res.mi.fi*=-1;
    return res;
}
bool invf[n*2-1];
Query dat[n*2-1];
void seg_update(int i,int v)
{
    vector<int> ls;
    int tmp=i;
    while(tmp)tmp=(tmp-1)/2,ls.pb(tmp);
    for(int ai=ls.size()-1;ai>=0;ai--)
    {
        int k=ls[ai];
        if(invf[k])
        {
            invf[k]=false;;
            invf[k*2+1]=!invf[k*2+1];
            invf[k*2+2]=!invf[k*2+2];
            dat[k*2+1]=invq(dat[k*2+1]);
            dat[k*2+2]=invq(dat[k*2+2]);
        }
    }
    A[i]=v;
    if(A[i]>=0)
    {
        dat[i+n-1].lma=mp(A[i],mp(i,i+1));
        dat[i+n-1].rma=mp(A[i],mp(i,i+1));
        dat[i+n-1].ma=mp(A[i],mp(i,i+1));
        dat[i+n-1].lmi=mp(0,mp(i,i));
        dat[i+n-1].rmi=mp(0,mp(i+1,i+1));
        dat[i+n-1].mi=mp(0,mp(i,i));
    }
    else
    {
        dat[i+n-1].lmi=mp(A[i],mp(i,i+1));
        dat[i+n-1].rmi=mp(A[i],mp(i,i+1));
        dat[i+n-1].mi=mp(A[i],mp(i,i+1));
        dat[i+n-1].lma=mp(0,mp(i,i));
        dat[i+n-1].rma=mp(0,mp(i+1,i+1));
        dat[i+n-1].ma=mp(0,mp(i,i));
    }
    dat[i+n-1].sum=mp(A[i],mp(i,i+1));
    invf[i+n-1]=false;
    i+=n-1;
    while(i)
    {
        i=(i-1)/2;
        dat[i]=unite(dat[i*2+1],dat[i*2+2]);
    }
}
void inv(int a,int b,int k,int l,int r)
{
    if(r<=a||b<=l)return;
    if(a<=l&&r<=b)
    {
        invf[k]=!invf[k];
        dat[k]=invq(dat[k]);
        return;
    }
    if(invf[k])
    {
        invf[k]=false;
        dat[k*2+1]=invq(dat[k*2+1]);
        dat[k*2+2]=invq(dat[k*2+2]);
        invf[k*2+1]=!invf[k*2+1];
        invf[k*2+2]=!invf[k*2+2];
    }
    inv(a,b,k*2+1,l,(l+r)/2);
    inv(a,b,k*2+2,(l+r)/2,r);
    dat[k]=unite(dat[k*2+1],dat[k*2+2]);
}
Query calc(int a,int b,int k,int l,int r)
{
    if(r<=a||b<=l)
    {
        Query res;
        res.sum.fi=INF;
        return res;
    }
    if(a<=l&&r<=b)return dat[k];
    if(invf[k])
    {
        invf[k]=false;
        dat[k*2+1]=invq(dat[k*2+1]);
        dat[k*2+2]=invq(dat[k*2+2]);
        invf[k*2+1]=!invf[k*2+1];
        invf[k*2+2]=!invf[k*2+2];
    }
    return unite(calc(a,b,k*2+1,l,(l+r)/2),calc(a,b,k*2+2,(l+r)/2,r));
}

int main()
{
    scanf("%d",&Q);
    rep(i,Q)scanf("%d",&A[i]);
    scanf("%d",&Q);
    rep(i,n)
    {
        if(A[i]>=0)
        {
            dat[i+n-1].lma=mp(A[i],mp(i,i+1));
            dat[i+n-1].rma=mp(A[i],mp(i,i+1));
            dat[i+n-1].ma=mp(A[i],mp(i,i+1));
            dat[i+n-1].lmi=mp(0,mp(i,i));
            dat[i+n-1].rmi=mp(0,mp(i+1,i+1));
            dat[i+n-1].mi=mp(0,mp(i,i));
        }
        else
        {
            dat[i+n-1].lmi=mp(A[i],mp(i,i+1));
            dat[i+n-1].rmi=mp(A[i],mp(i,i+1));
            dat[i+n-1].mi=mp(A[i],mp(i,i+1));
            dat[i+n-1].lma=mp(0,mp(i,i));
            dat[i+n-1].rma=mp(0,mp(i+1,i+1));
            dat[i+n-1].ma=mp(0,mp(i,i));
        }
        dat[i+n-1].sum=mp(A[i],mp(i,i+1));
    }
    for(int i=n-2;i>=0;i--)dat[i]=unite(dat[i*2+1],dat[i*2+2]);
    while(Q--)
    {
        scanf("%d",&V);
        if(V==0)
        {
            scanf("%d%d",&P,&V);P--;
            seg_update(P,V);
        }
        else
        {
            scanf("%d%d%d",&L,&R,&K),L--;
            Query res=calc(L,R,0,0,n);
            int ans=res.ma.fi;
            vector<pii> iv;
            int tt=ans;
            rep(i,K-1)
            {
                if(res.ma.fi==0)break;
                iv.pb(res.ma.se);
                inv(res.ma.se.fi,res.ma.se.se,0,0,n);
                res=calc(L,R,0,0,n);

                MAX(ans,tt+res.ma.fi);
                tt+=res.ma.fi;
            }
            rep(i,iv.size())inv(iv[i].fi,iv[i].se,0,0,n);
            printf("%d\n",ans);
        }
    }
}


#include <cstdio>
#include <vector>
#include <cstring>
#include <functional>
#include <algorithm>
#include <math.h>
#include <bitset>
#include <set>
#include <queue>
#include <iostream>
#include <string>
#include <sstream>
#include <stack>
#include <complex>
#include <numeric>
#include <map>
#include <time.h>
using namespace std;
typedef long double ld;
typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int uint;
typedef pair<int,int> pii;
typedef pair<int,ll> pil;
typedef pair<ll,int> pli;
typedef pair<ll,ll> pll;
typedef pair<pii,ll> ppl;
typedef pair<ll,pii> plp;
typedef pair<int,pii> pip;
typedef pair<pii,int> ppi;
typedef pair<pii,pii> ppp;
typedef pair<double,int> pdi;
typedef pair<double,pii> pdp;
typedef pair<double,double> pdd;
typedef pair<pdd,double> pd3;
typedef vector<double> vec;
typedef vector<vec> mat;
#define rep(i,n) for (int (i) = 0; (i) < (n); (i)++)
#define repn(i,a,n) for (int (i) = (a); (i) < (n); (i)++)
#define ALL(x) (x).begin(),(x).end()
#define pb push_back
#define SORT(x) sort((x).begin(),(x).end())
#define SORTN(x,n) sort((x),(x)+(n))
#define ERASE(x) (x).erase(unique((x).begin(),(x).end()),(x).end())
#define COUNT(x,c) count((x).begin(),(x).end(),(c))
#define REMOVE(x,c) (x).erase(remove((x).begin(),(x).end(),(c)),(x).end())
#define REVERSE(x) reverse((x).begin(),(x).end())
#define FORIT(it,v) for(__typeof((v).begin()) it=(v).begin();it!=(v).end();it++)
#define LB(x,a) lower_bound((x).begin(),(x).end(),(a))-(x).begin()
#define lb(x,a) lower_bound((x).begin(),(x).end(),(a))
#define LBN(x,a,n) lower_bound((x),(x)+(n),(a))-(x)
#define lbN(x,a,n) lower_bound((x),(x)+(n),(a))
#define UB(x,a) upper_bound((x).begin(),(x).end(),(a))-(x).begin()
#define ub(x,a) upper_bound((x).begin(),(x).end(),(a))
#define BS(x,a) binary_search((x).begin(),(x).end(),(a))
#define BS2(x,n,a) binary_search((x),(x)+(n),(a))
#define NB(x) (((x)&~((x)+((x)&-(x))))/((x)&-(x))>>1)|((x)+((x)&-(x)))
#define NP(x) next_permutation((x).begin(),(x).end())
#define MM(x,p) memset((x),(p),sizeof(x))
#define SQ(x) (x)*(x)
#define SC(c1,c2) strcmp(c1,c2)==0
#define mp make_pair
#define INF (1<<30)
#define INFL (1LL<<61)
#define fi first
#define se second
#define MOD 1000000007
#define EPS 1e-12
#define MIN(x,a) x=min(x,a)
#define MAX(x,a) x=max(x,a)
#define madd(x,a) x=(x+a)%MOD
#define msub(x,a) x=(x+MOD-a)%MOD
#define OUTPUT(x) rep(i,x.size())printf("%d%c",x[i],i+1==x.size()?'\n':' ');

int Q,P,V,L,R,K;
const int n=1<<18;
int A[n];

struct Query
{
    pip lma,rma,lmi,rmi,sum,ma,mi;
};
pip con(pip p1,pip p2)
{
    return mp(p1.fi+p2.fi,mp(p1.se.fi,p2.se.se));
}
Query unite(Query q1,Query q2)
{
    if(q1.sum.fi==INF)return q2;
    if(q2.sum.fi==INF)return q1;
    Query res;
    res.lma=max(q1.lma,con(q1.sum,q2.lma));
    res.rma=max(q2.rma,con(q1.rma,q2.sum));
    res.lmi=min(q1.lmi,con(q1.sum,q2.lmi));
    res.rmi=min(q2.rmi,con(q1.rmi,q2.sum));
    res.ma=max(max(q1.ma,q2.ma),con(q1.rma,q2.lma));
    res.mi=min(max(q1.mi,q2.mi),con(q1.rmi,q2.lmi));
    res.sum=con(q1.sum,q2.sum);
    return res;
}
Query invq(Query q)
{
    Query res;
    res.lmi=q.lma,res.rmi=q.rma,res.lma=q.lmi,res.rma=q.rmi,res.sum=q.sum,res.ma=q.mi,res.mi=q.ma;
    res.lmi.fi*=-1,res.rmi.fi*=-1,res.lma.fi*=-1,res.rma.fi*=-1,res.sum.fi*=-1,res.ma.fi*=-1,res.mi.fi*=-1;
    return res;
}
bool invf[n*2-1];
Query dat[n*2-1];
void seg_update(int i,int v)
{
    vector<int> ls;
    int tmp=i;
    while(tmp)tmp=(tmp-1)/2,ls.pb(tmp);
    for(int ai=ls.size()-1;ai>=0;ai--)
    {
        int k=ls[ai];
        if(invf[k])
        {
            invf[k]=false;;
            invf[k*2+1]=invf[k*2+2]=true;
            dat[k*2+1]=invq(dat[k*2+1]);
            dat[k*2+2]=invq(dat[k*2+2]);
        }
    }
    A[i]=v;
    if(A[i]>=0)
    {
        dat[i+n-1].lma=mp(A[i],mp(i,i+1));
        dat[i+n-1].rma=mp(A[i],mp(i,i+1));
        dat[i+n-1].ma=mp(A[i],mp(i,i+1));
        dat[i+n-1].lmi=mp(0,mp(i,i));
        dat[i+n-1].rmi=mp(0,mp(i+1,i+1));
        dat[i+n-1].mi=mp(0,mp(i,i));
    }
    else
    {
        dat[i+n-1].lmi=mp(A[i],mp(i,i+1));
        dat[i+n-1].rmi=mp(A[i],mp(i,i+1));
        dat[i+n-1].mi=mp(A[i],mp(i,i+1));
        dat[i+n-1].lma=mp(0,mp(i,i));
        dat[i+n-1].rma=mp(0,mp(i+1,i+1));
        dat[i+n-1].ma=mp(0,mp(i,i));
    }
    dat[i+n-1].sum=mp(A[i],mp(i,i+1));
    invf[i+n-1]=false;
    i+=n-1;
    while(i)
    {
        i=(i-1)/2;
        dat[i]=unite(dat[i*2+1],dat[i*2+2]);
    }
}
void inv(int a,int b,int k,int l,int r)
{
    if(r<=a||b<=l)return;
    if(a<=l&&r<=b)
    {
        invf[k]=!invf[k];
        dat[k]=invq(dat[k]);
        return;
    }
    if(invf[k])
    {
        invf[k]=false;
        dat[k*2+1]=invq(dat[k*2+1]);
        dat[k*2+2]=invq(dat[k*2+2]);
        invf[k*2+1]=!invf[k*2+1];
        invf[k*2+2]=!invf[k*2+2];
    }
    inv(a,b,k*2+1,l,(l+r)/2);
    inv(a,b,k*2+2,(l+r)/2,r);
    dat[k]=unite(dat[k*2+1],dat[k*2+2]);
}
Query calc(int a,int b,int k,int l,int r)
{
    if(r<=a||b<=l)
    {
        Query res;
        res.sum.fi=INF;
        return res;
    }
    if(a<=l&&r<=b)return dat[k];
    if(invf[k])
    {
        invf[k]=false;
        dat[k*2+1]=invq(dat[k*2+1]);
        dat[k*2+2]=invq(dat[k*2+2]);
        invf[k*2+1]=!invf[k*2+1];
        invf[k*2+2]=!invf[k*2+2];
    }
    return unite(calc(a,b,k*2+1,l,(l+r)/2),calc(a,b,k*2+2,(l+r)/2,r));
}

int main()
{
    scanf("%d",&Q);
    rep(i,Q)scanf("%d",&A[i]);
    scanf("%d",&Q);
    rep(i,n)
    {
        if(A[i]>=0)
        {
            dat[i+n-1].lma=mp(A[i],mp(i,i+1));
            dat[i+n-1].rma=mp(A[i],mp(i,i+1));
            dat[i+n-1].ma=mp(A[i],mp(i,i+1));
            dat[i+n-1].lmi=mp(0,mp(i,i));
            dat[i+n-1].rmi=mp(0,mp(i+1,i+1));
            dat[i+n-1].mi=mp(0,mp(i,i));
        }
        else
        {
            dat[i+n-1].lmi=mp(A[i],mp(i,i+1));
            dat[i+n-1].rmi=mp(A[i],mp(i,i+1));
            dat[i+n-1].mi=mp(A[i],mp(i,i+1));
            dat[i+n-1].lma=mp(0,mp(i,i));
            dat[i+n-1].rma=mp(0,mp(i+1,i+1));
            dat[i+n-1].ma=mp(0,mp(i,i));
        }
        dat[i+n-1].sum=mp(A[i],mp(i,i+1));
    }
    for(int i=n-2;i>=0;i--)dat[i]=unite(dat[i*2+1],dat[i*2+2]);
    while(Q--)
    {
        scanf("%d",&V);
        if(V==0)
        {
            scanf("%d%d",&P,&V);P--;
            seg_update(P,V);
        }
        else
        {
            scanf("%d%d%d",&L,&R,&K),L--;
            Query res=calc(L,R,0,0,n);
            int ans=res.ma.fi;
            vector<pii> iv;
            int tt=ans;
            rep(i,K-1)
            {
                if(res.ma.fi==0)break;
                iv.pb(res.ma.se);
                inv(res.ma.se.fi,res.ma.se.se,0,0,n);
                res=calc(L,R,0,0,n);

                MAX(ans,tt+res.ma.fi);
                tt+=res.ma.fi;
            }
            rep(i,iv.size())inv(iv[i].fi,iv[i].se,0,0,n);
            printf("%d\n",ans);
        }
    }
}


#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=100010;
int n,m,b[N],ans;
struct Segment_Tree
{
	int tot;
	int L[30],R[30],T;
	struct Data{int l,r,mid,sum,size,id_l,id_r,id_mid[2];}now;
	Data merge(Data a,Data b)
	{
		Data re;
		re.size=a.size+b.size;
		re.sum=a.sum+b.sum;
		if(a.l>a.sum+b.l)re.l=a.l,re.id_l=a.id_l;
		else re.l=a.sum+b.l,re.id_l=b.id_l+a.size;
		if(b.r>b.sum+a.r)re.r=b.r,re.id_r=b.id_r;
		else re.r=b.sum+a.r,re.id_r=a.id_r+b.size;
		if(a.mid>b.mid)re.mid=a.mid,re.id_mid[0]=a.id_mid[0],re.id_mid[1]=a.id_mid[1];
		else re.mid=b.mid,re.id_mid[0]=a.size+b.id_mid[0],re.id_mid[1]=a.size+b.id_mid[1];
		if(a.r+b.l>re.mid)re.mid=a.r+b.l,re.id_mid[0]=a.size-a.id_r+1,re.id_mid[1]=b.id_l+a.size;
		return re;
	}
	Data build(int c)
	{
		Data re;
		re.sum=c;re.size=1;
		if(c>0)
		{
			re.l=re.r=re.mid=c;
			re.id_l=re.id_r=re.id_mid[0]=re.id_mid[1]=1;
		}
		else
		{
			re.l=re.r=re.mid=0;
			re.id_l=re.id_mid[1]=re.id_r=0;re.id_mid[0]=1;
		}
		return re;
	}
	struct Node{int l,r,son[2],lazy;Data data[2];}a[N<<1];
	void update(int x)
	{
		push(x);push(a[x].son[0]);push(a[x].son[1]);
		a[x].data[0]=merge(a[a[x].son[0]].data[0],a[a[x].son[1]].data[0]);
		a[x].data[1]=merge(a[a[x].son[0]].data[1],a[a[x].son[1]].data[1]);
	}
	void push(int x)
	{
		if(a[x].lazy)
		{
			a[a[x].son[0]].lazy^=1;
			a[a[x].son[1]].lazy^=1;
			a[x].lazy=0;
			swap(a[x].data[0],a[x].data[1]);
		}
	}
	void build(int l,int r,int x=1)
	{
		if(x==1)tot=1;
		a[x].l=l;a[x].r=r;
		a[x].data[0].size=a[x].data[1].size=r-l+1;
		if(l==r)
		{
			a[x].data[0]=build(b[l]);
			a[x].data[1]=build(-b[l]);
		}
		else
		{
			int mid=(a[x].l+a[x].r)>>1;
			a[x].son[0]=++tot;
			build(l,mid,tot);
			a[x].son[1]=++tot;
			build(mid+1,r,tot);
			update(x);
		}
	}
	void insert(int id,int c,int x=1)
	{
		push(x);
		if(a[x].l==a[x].r)
		{
			a[x].data[0]=build(c);
			a[x].data[1]=build(-c);
		}
		else
		{
			int mid=(a[x].l+a[x].r)>>1;
			if(id<=mid)insert(id,c,a[x].son[0]);
			else insert(id,c,a[x].son[1]);
			update(x);
		}
	}
	int search(int l,int r)
	{
		now=build(0);
		search(l,r,1);
			//printf("search:(%d,%d) return:(%d,%d)",l,r,L[T],R[T]);
			//draw(now);
			//draw(1);
		if(now.mid==0)return 0;
		else
		{
			reverse(l+now.id_mid[0]-2,l+now.id_mid[1]-2);
			T++;
			L[T]=l+now.id_mid[0]-2;
			R[T]=l+now.id_mid[1]-2;
			return now.mid;
		}
	}
	void clear()
	{
		while(T)
		{
			reverse(L[T],R[T]);
			T--;
		}
	}
	void reverse(int l,int r,int x=1)
	{
		push(x);
		if(a[x].l>=l&&a[x].r<=r)a[x].lazy^=1;
		else
		{
			int mid=(a[x].l+a[x].r)>>1;
			if(l<=mid)reverse(l,r,a[x].son[0]);
			if(r>mid)reverse(l,r,a[x].son[1]);
			update(x);
		}
	}
	void search(int l,int r,int x)
	{
		push(x);
		if(a[x].l>=l&&a[x].r<=r)now=merge(now,a[x].data[0]);
		else
		{
			int mid=(a[x].l+a[x].r)>>1;
			if(l<=mid)search(l,r,a[x].son[0]);
			if(r>mid)search(l,r,a[x].son[1]);
		}
	}
	void draw(Data a)
	{
		printf("   size=%d sum=%d l=%d r=%d mid=%d l:(1,%d),r:(%d,%d),mid:(%d,%d)\n",a.size,a.sum,a.l,a.r,a.mid,a.id_l,a.size+1-a.id_r,a.size,a.id_mid[0],a.id_mid[1]);
	}
	void draw(int t)
	{
		for(int i=1;i<=tot;i++)
		{
			printf("node:%d len(%d,%d) son(%d,%d) lazy=%d data:\n",i,a[i].l,a[i].r,a[i].son[0],a[i].son[1],a[i].lazy);
			if(t>0){draw(a[i].data[0]);draw(a[i].data[1]);}
		}
	}
}tree;
int main()
{
	int i,j,k,l;
	scanf("%d",&n);
	for(i=1;i<=n;i++)scanf("%d",&b[i]);
	tree.build(1,n);
	//tree.draw(0);
	scanf("%d",&m);

	while(m--)
	{
		scanf("%d%d%d",&i,&j,&k);
		if(i==0)
		{
			tree.insert(j,k);
		}
		else
		{
			scanf("%d",&l);
			ans=0;
			while(l--)ans+=tree.search(j,k);
			tree.clear();
			printf("%d\n",ans);
		}
	}
	return 0;
}


#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=100010;
int n,m,b[N],ans;
struct Segment_Tree
{
	int tot;
	int L[30],R[30],T;
	struct Data{int l,r,mid,sum,size,id_l,id_r,id_mid[2];}now;
	Data merge(Data a,Data b)
	{
		Data re;
		re.size=a.size+b.size;
		re.sum=a.sum+b.sum;
		if(a.l>a.sum+b.l)re.l=a.l,re.id_l=a.id_l;
		else re.l=a.sum+b.l,re.id_l=b.id_l+a.size;
		if(b.r>b.sum+a.r)re.r=b.r,re.id_r=b.id_r;
		else re.r=b.sum+a.r,re.id_r=a.id_r+b.size;
		if(a.mid>b.mid)re.mid=a.mid,re.id_mid[0]=a.id_mid[0],re.id_mid[1]=a.id_mid[1];
		else re.mid=b.mid,re.id_mid[0]=a.size+b.id_mid[0],re.id_mid[1]=a.size+b.id_mid[1];
		if(a.r+b.l>re.mid)re.mid=a.r+b.l,re.id_mid[0]=a.size-a.id_r+1,re.id_mid[1]=b.id_l+a.size;
		return re;
	}
	Data build(int c)
	{
		Data re;
		re.sum=c;re.size=1;
		if(c>0)
		{
			re.l=re.r=re.mid=c;
			re.id_l=re.id_r=re.id_mid[0]=re.id_mid[1]=1;
		}
		else
		{
			re.l=re.r=re.mid=0;
			re.id_l=re.id_mid[1]=-1;re.id_r=re.id_mid[0]=2;
		}
		return re;
	}
	struct Node{int l,r,son[2],lazy;Data data[2];}a[N<<1];
	void update(int x)
	{
		push(x);push(a[x].son[0]);push(a[x].son[1]);
		a[x].data[0]=merge(a[a[x].son[0]].data[0],a[a[x].son[1]].data[0]);
		a[x].data[1]=merge(a[a[x].son[0]].data[1],a[a[x].son[1]].data[1]);
	}
	void push(int x)
	{
		if(a[x].lazy)
		{
			a[a[x].son[0]].lazy^=1;
			a[a[x].son[1]].lazy^=1;
			a[x].lazy=0;
			swap(a[x].data[0],a[x].data[1]);
		}
	}
	void build(int l,int r,int x=1)
	{
		if(x==1)tot=1;
		a[x].l=l;a[x].r=r;
		a[x].data[0].size=a[x].data[1].size=r-l+1;
		if(l==r)
		{
			a[x].data[0]=build(b[l]);
			a[x].data[1]=build(-b[l]);
		}
		else
		{
			int mid=(a[x].l+a[x].r)>>1;
			a[x].son[0]=++tot;
			build(l,mid,tot);
			a[x].son[1]=++tot;
			build(mid+1,r,tot);
			update(x);
		}
	}
	void insert(int id,int c,int x=1)
	{
		push(x);
		if(a[x].l==a[x].r)
		{
			a[x].data[0]=build(c);
			a[x].data[1]=build(-c);
		}
		else
		{
			int mid=(a[x].l+a[x].r)>>1;
			if(id<=mid)insert(id,c,a[x].son[0]);
			else insert(id,c,a[x].son[1]);
			update(x);
		}
	}
	int search(int l,int r)
	{
		now=build(0);
		search(l,r,1);
			//printf("search:(%d,%d) return:(%d,%d)",l,r,L[T],R[T]);
			//draw(now);
			//draw(1);
		if(now.mid==0)return 0;
		else
		{
			reverse(l+now.id_mid[0]-2,l+now.id_mid[1]-2);
			T++;
			L[T]=l+now.id_mid[0]-2;
			R[T]=l+now.id_mid[1]-2;
			return now.mid;
		}
	}
	void clear()
	{
		while(T)
		{
			reverse(L[T],R[T]);
			T--;
		}
	}
	void reverse(int l,int r,int x=1)
	{
		push(x);
		if(a[x].l>=l&&a[x].r<=r)a[x].lazy^=1;
		else
		{
			int mid=(a[x].l+a[x].r)>>1;
			if(l<=mid)reverse(l,r,a[x].son[0]);
			if(r>mid)reverse(l,r,a[x].son[1]);
			update(x);
		}
	}
	void search(int l,int r,int x)
	{
		push(x);
		if(a[x].l>=l&&a[x].r<=r)now=merge(now,a[x].data[0]);
		else
		{
			int mid=(a[x].l+a[x].r)>>1;
			if(l<=mid)search(l,r,a[x].son[0]);
			if(r>mid)search(l,r,a[x].son[1]);
		}
	}
	void draw(Data a)
	{
		printf("   size=%d sum=%d l=%d r=%d mid=%d l:(1,%d),r:(%d,%d),mid:(%d,%d)\n",a.size,a.sum,a.l,a.r,a.mid,a.id_l,a.size+1-a.id_r,a.size,a.id_mid[0],a.id_mid[1]);
	}
	void draw(int t)
	{
		for(int i=1;i<=tot;i++)
		{
			printf("node:%d len(%d,%d) son(%d,%d) lazy=%d data:\n",i,a[i].l,a[i].r,a[i].son[0],a[i].son[1],a[i].lazy);
			if(t>0){draw(a[i].data[0]);draw(a[i].data[1]);}
		}
	}
}tree;
int main()
{
	int i,j,k,l;
	scanf("%d",&n);
	for(i=1;i<=n;i++)scanf("%d",&b[i]);
	tree.build(1,n);
	//tree.draw(0);
	scanf("%d",&m);
	while(m--)
	{
		scanf("%d%d%d",&i,&j,&k);
		if(i==0)
		{
			tree.insert(j,k);
		}
		else
		{
			scanf("%d",&l);
			ans=0;
			while(l--)ans+=tree.search(j,k);
			tree.clear();
			printf("%d\n",ans);
		}
	}
	return 0;
}


#include<cstdio>
#include<vector>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;

vector<pair<int, int> > v;

bool buy(const int i, const int j) {
	return j != -1 && (v[i].second + v[j].second >= 0 &&
		(v[i].first == v[j].first || v[i].first - 1 == v[j].first));
}

const int N = 100005 << 1;
long long dp[N][4];
pair<int, int> fa[N][4], pa[N][4];

void update(const int ti, const int tj, const int oi, const int oj, const int delta, const pair<int, int> tr) {
	if (dp[ti][tj] < dp[oi][oj] + delta) {
		dp[ti][tj] = dp[oi][oj] + delta;
		fa[ti][tj] = make_pair(oi, oj);
		pa[ti][tj] = tr;
	}
}

int main() {
	int n;
	scanf("%d", &n);
	vector<pair<pair<int, int>, int> > tmp;
	for (int i = 0; i < n; ++i) {
		int tc, ts;
		scanf("%d%d", &tc, &ts);
		tmp.push_back(make_pair(make_pair(ts, -tc), i + 1));
	}
	int m;
	scanf("%d", &m);
	for (int i = 0; i < m; ++i) {
		int td, tl;
		scanf("%d%d", &td, &tl);
		++tl;
		tmp.push_back(make_pair(make_pair(tl, td), i + 1));
	}
	for (int i = 0; i < (int)tmp.size(); ++i) {
		v.push_back(tmp[i].first);
	}
	sort(v.begin(), v.end());
	sort(tmp.begin(), tmp.end());
	int lastshoe = -1, currentshoe = -1;
	for (int i = 0; i < (int) v.size(); ++i) {
		if (v[i].second < 0) {
			lastshoe = currentshoe;
			currentshoe = i;
			for (int j = 0; j < 4; ++j) {
				update(i + 1, j >> 1, i, j, 0, make_pair(0, 0));
			}
		} else {
			for (int j = 0; j < 4; ++j) {
				update(i + 1, j, i, j, 0, make_pair(0, 0));
				if (~j & 1) {
					if (buy(i, lastshoe)) {
						update(i + 1, j | 1, i, j, -v[lastshoe].second, make_pair(tmp[i].second, tmp[lastshoe].second));
					}
				}
				if (~j & 2) {
					if (buy(i, currentshoe)) {
						update(i + 1, j | 2, i, j, -v[currentshoe].second, make_pair(tmp[i].second, tmp[currentshoe].second));
					}
				}
			}
		}
	}
	int ed = v.size(), ansi = 0;
	for (int j = 0; j < 4; ++j) {
		if (dp[ed][j] > dp[ed][ansi]) {
			ansi = j;
		}
	}
	cout << dp[ed][ansi] << endl;
	vector<pair<int, int> > met;
	while (ed) {
		if (pa[ed][ansi].first) {
			met.push_back(pa[ed][ansi]);
		}
		pair<int, int> f = fa[ed][ansi];
		ed = f.first, ansi = f.second;
	}
	printf("%d\n", (int)met.size());
	for (int i = 0; i < (int)met.size(); ++i) {
		printf("%d %d\n", met[i].first, met[i].second);
	}
	return 0;
}


#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;

const int INF = 100000000;

struct Data {
	int dp[2][21][2];

	Data(const int i = 0) {
		memset(dp, 0, sizeof(dp));
		dp[0][0][1] = -INF;
		dp[1][0][0] = max(i, 0);
		dp[1][0][1] = i;
		dp[0][1][1] = i;
		renew();
	}

	void renew() {
		for (int i = 1; i <= 20; ++i) {
			for (int in = 0; in < 2; ++in) {
				for (int out = 0; out < 2; ++out) {
					dp[in][i][out] = max(dp[in][i][out], dp[in][i - 1][out]);
				}
			}
		}
	}
};

Data merge(const Data a, const Data b) {
	Data ret;
	for (int in = 0; in < 2; ++in) {
		for (int out = 0; out < 2; ++out) {
			for (int w = 0; w <= 20; ++w) {
				ret.dp[in][w][out] = -INF;
			}
			for (int mid = 0; mid < 2; ++mid) {
				int best = 0;
				for (int w = 0; w <= 20; ++w) {
					ret.dp[in][w][out] = max(ret.dp[in][w][out], a.dp[in][best][mid] + b.dp[mid][w - best][out]);
					if (w < 20 && a.dp[in][best + 1][mid] + b.dp[mid][w - best][out] > a.dp[in][best][mid] + b.dp[mid][w + 1 - best][out]) {
						++best;
					}
				}
			}
		}
	}
	ret.renew();
	return ret;
}

int n;

const int N = 100005;
Data data[N << 1];

int getID(const int l, const int r) {
	return l + r | l != r;
}

void update(const int l, const int r) {
	int k = (l + r) >> 1;
	data[getID(l, r)] = merge(data[getID(l, k)], data[getID(k + 1, r)]);
}

void segChange(const int l, const int r, const int pos, const int val) {
	if (pos < l || pos > r) {
		return;
	}
	if (l == r) {
		data[getID(l, r)] = Data(val);
	} else {
		int k = (l + r) >> 1;
		segChange(l, k, pos, val);
		segChange(k + 1, r, pos, val);
		update(l, r);
	}
}

Data segAsk(const int l, const int r, const int a, const int b) {
	if (a <= l && r <= b) {
		return data[getID(l, r)];
	}
	int k = (l + r) >> 1;
	if (k < a) {
		return segAsk(k + 1, r, a, b);
	}
	if (b <= k) {
		return segAsk(l, k, a, b);
	}
	return merge(segAsk(l, k, a, b), segAsk(k + 1, r, a, b));
}

int main() {
	scanf("%d", &n);
	for (int i = 0; i < n; ++i) {
		int t1;
		scanf("%d", &t1);
		segChange(0, n - 1, i, t1);
	}
	int m;
	scanf("%d", &m);
	while (m--) {
		int type;
		scanf("%d", &type);
		if (type == 0) {
			int t1, t2;
			scanf("%d%d", &t1, &t2);
			--t1;
			segChange(0, n - 1, t1, t2);
		} else {
			int l, r, k;
			scanf("%d%d%d", &l, &r, &k);
			--l, --r;
			Data ans = segAsk(0, n - 1, l, r);
			printf("%d\n", max(ans.dp[0][k][0], ans.dp[0][k][1]));
		}
	}
	return 0;
}


#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;

int n;

struct Seq {
	int val, st, ed;

	Seq(const int val = 0, const int st = 0, const int ed = 0) : val(val), st(st), ed(ed) {}
};

bool operator < (const Seq a, const Seq b) {
	return a.val < b.val;
}

Seq operator + (const Seq a, const Seq b) {
	return Seq(a.val + b.val, a.st, b.ed);
}

struct Data {
	int tag;
	Seq sum, left, right, best;

	Data(const int pos = 0, const int val = 0, const int tag = 0) : tag(tag) {
		sum = Seq(val, pos, pos);
		if ((val >= 0) ^ tag) {
			left = right = best = sum;
		} else {
			left = Seq(0, pos, pos - 1);
			right = Seq(0, pos + 1, pos);
			best = Seq(0, pos, pos - 1);
		}
	}

	void reverse() {
		tag = 1 ^ tag;
		sum.val = -sum.val;
		left.val = -left.val;
		right.val = -right.val;
		best.val = -best.val;
	}
};

Data merge(const Data a, const Data b) {
	Data ret;
	ret.tag = a.tag;
	ret.sum = a.sum + b.sum;
	if (!ret.tag) {
		ret.left = max(a.left, a.sum + b.left);
		ret.right = max(a.right + b.sum, b.right);
		ret.best = max(a.right + b.left, max(a.best, b.best));
	} else {
		ret.left = min(a.left, a.sum + b.left);
		ret.right = min(a.right + b.sum, b.right);
		ret.best = min(a.right + b.left, min(a.best, b.best));
	}
	return ret;
}

const int N = 100005;

Data data[N << 1][2];

int getID(const int l, const int r) {
	return l + r | l != r;
}

void update(const int l, const int r) {
	int k = (l + r) >> 1;
	int x = getID(l, r), lc = getID(l, k), rc = getID(k + 1, r);
	data[x][0] = merge(data[lc][0], data[rc][0]);
	data[x][1] = merge(data[lc][1], data[rc][1]);
}

void segChange(const int l, const int r, const int pos, const int val) {
	if (pos < l || r < pos) {
		return;
	}
	if (l == r) {
		int x = getID(l, r);
		data[x][0] = Data(l, val, 0);
		data[x][1] = Data(l, val, 1);
	} else {
		int k = (l + r) >> 1;
		segChange(l, k, pos, val);
		segChange(k + 1, r, pos, val);
		update(l, r);
	}
}

int tag[N << 1];

void segReverse(const int l, const int r, const int a, const int b);

void pushdown(const int l, const int r) {
	int x = getID(l, r);
	if (tag[x]) {
		int k = (l + r) >> 1;
		tag[x] ^= 1;
		segReverse(l, k, l, r);
		segReverse(k + 1, r, l, r);
		update(l, r);
	}
}

void segReverse(const int l, const int r, const int a, const int b) {
	if (b < l || r < a) {
		return;
	}
	if (a <= l && r <= b) {
		int x = getID(l, r);
		tag[x] ^= 1;
		swap(data[x][0], data[x][1]);
		data[x][0].reverse();
		data[x][1].reverse();
		return;
	}
	pushdown(l, r);
	int k = (l + r) >> 1;
	segReverse(l, k, a, b);
	segReverse(k + 1, r, a, b);
	update(l, r);
}

Data segAsk(const int l, const int r, const int a, const int b) {
	if (a <= l && r <= b) {
		return data[getID(l, r)][0];
	}
	pushdown(l, r);
	int k = (l + r) >> 1;
	if (b <= k) {
		return segAsk(l, k, a, b);
	}
	if (k < a) {
		return segAsk(k + 1, r, a, b);
	}
	return merge(segAsk(l, k, a, b), segAsk(k + 1, r, a, b));
}

int main() {
	scanf("%d", &n);
	for (int i = 0; i < n; ++ i) {
		int t1;
		scanf("%d", &t1);
		segChange(0, n - 1, i, t1);
	}
	int m;
	scanf("%d", &m);
	while (m--) {
		int type;
		scanf("%d", &type);
		if (type) {
			int l, r, k;
			scanf("%d%d%d", &l, &r, &k);
			--l, --r;
			int ans = 0;
			vector<pair<int, int> > v;
			for (int i = 0; i < k; ++i) {
				Seq tmp = segAsk(0, n - 1, l, r).best;
				if (tmp.val > 0) {
					ans += tmp.val;
					segReverse(0, n - 1, tmp.st, tmp.ed);
					v.push_back(make_pair(tmp.st, tmp.ed));
				}
			}
			printf("%d\n", ans);
			for (int i = 0; i < (int)v.size(); ++i) {
				segReverse(0, n - 1, v[i].first, v[i].second);
			}
		} else {
			int tpos, tval;
			scanf("%d%d", &tpos, &tval);
			--tpos;
			segChange(0, n - 1, tpos, tval);
		}
	}
	return 0;
}


#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<cmath>
using namespace std;
#define N 110000
struct rec{
       int sum[2],sl[2],sr[2],s[2],recl[2],recr[2],recll[2],recrr[2];
       }tr[N*4];
int a[N],lab[N],ql[100],qr[100],n;
rec merge(rec a,rec b){
    rec c;
    for(int k=0;k<=1;k++){
      c.sum[k]=a.sum[k]+b.sum[k];
      if(a.sl[k]>a.sum[k]+b.sl[k])c.sl[k]=a.sl[k],c.recl[k]=a.recl[k];
      else c.sl[k]=a.sum[k]+b.sl[k],c.recl[k]=b.recl[k];
      if(b.sr[k]>b.sum[k]+a.sr[k])c.sr[k]=b.sr[k],c.recr[k]=b.recr[k];
      else c.sr[k]=b.sum[k]+a.sr[k],c.recr[k]=a.recr[k];
      if(a.s[k]>b.s[k] && a.s[k]>a.sr[k]+b.sl[k])c.s[k]=a.s[k],c.recll[k]=a.recll[k],c.recrr[k]=a.recrr[k];
      else
      if(b.s[k]>a.sr[k]+b.sl[k])c.s[k]=b.s[k],c.recll[k]=b.recll[k],c.recrr[k]=b.recrr[k];
      else c.s[k]=a.sr[k]+b.sl[k],c.recll[k]=a.recr[k],c.recrr[k]=b.recl[k];
    }
    return c;
}
void down(int u,int l,int r){
     if(!lab[u])return;
     swap(tr[u].sum[0],tr[u].sum[1]);
     swap(tr[u].sl[0],tr[u].sl[1]);
     swap(tr[u].sr[0],tr[u].sr[1]);
     swap(tr[u].s[0],tr[u].s[1]);
     swap(tr[u].recl[0],tr[u].recl[1]);
     swap(tr[u].recr[0],tr[u].recr[1]);
     swap(tr[u].recll[0],tr[u].recll[1]);
     swap(tr[u].recrr[0],tr[u].recrr[1]);
     if(l!=r)lab[u*2]^=1,lab[u*2+1]^=1;
     lab[u]=0;
}
void debug(int u,int l,int r){
     printf("%d %d %d %d %d %d\n",l,r,tr[u].sl[0],tr[u].sr[0],tr[u].s[0],tr[u].sum[0]);
     }
void build(int u,int l,int r){
     if(l==r){
       tr[u].sum[0]=tr[u].sl[0]=tr[u].sr[0]=tr[u].s[0]=a[l];
       tr[u].sum[1]=tr[u].sl[1]=tr[u].sr[1]=tr[u].s[1]=-a[l];
       tr[u].recl[0]=tr[u].recl[1]=tr[u].recr[0]=tr[u].recr[1]=l;
       tr[u].recll[0]=tr[u].recll[1]=tr[u].recrr[0]=tr[u].recrr[1]=l;
     //  debug(u,l,r);
       return;
     }
     int mid=(l+r)/2;
     build(u*2,l,mid);
     build(u*2+1,mid+1,r);
     tr[u]=merge(tr[u*2],tr[u*2+1]);
   //  debug(u,l,r);
}
void change(int u,int l,int r,int x){
     down(u,l,r);
     if(l==r){
       tr[u].sum[0]=tr[u].sl[0]=tr[u].sr[0]=tr[u].s[0]=a[l];
       tr[u].sum[1]=tr[u].sl[1]=tr[u].sr[1]=tr[u].s[1]=-a[l];
       tr[u].recl[0]=tr[u].recl[1]=tr[u].recr[0]=tr[u].recr[1]=l;
       tr[u].recll[0]=tr[u].recll[1]=tr[u].recrr[0]=tr[u].recrr[1]=l;
       return;
     }
     int mid=(l+r)/2;
     if(x<=mid)change(u*2,l,mid,x);
     else change(u*2+1,mid+1,r,x);
     tr[u]=merge(tr[u*2],tr[u*2+1]);
}
rec query(int u,int l,int r,int x,int y){
    down(u,l,r);
    if(x<=l && y>=r)return tr[u];
    int mid=(l+r)/2;
    if(y<=mid)return query(u*2,l,mid,x,y);
    if(x>mid)return query(u*2+1,mid+1,r,x,y);
    return merge(query(u*2,l,mid,x,y),query(u*2+1,mid+1,r,x,y));
}
void rev(int u,int l,int r,int x,int y){
     down(u,l,r);
     if(x>r || y<l)return;
     if(x<=l && y>=r){
       lab[u]=1;
       down(u,l,r);
       return;
     }
     int mid=(l+r)/2;
     rev(u*2,l,mid,x,y);
     rev(u*2+1,mid+1,r,x,y);
     tr[u]=merge(tr[u*2],tr[u*2+1]);
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++)scanf("%d",&a[i]);
    build(1,1,n);
    int T;
    scanf("%d",&T);
    while(T--){
      int kk;
      scanf("%d",&kk);
      if(!kk){
        int x,y;
        scanf("%d%d",&x,&y);
        a[x]=y;
        change(1,1,n,x);
      }
      else{
        int l,r,k,Ans=0,tot=0,num=0;
        scanf("%d%d%d",&l,&r,&k);
        while(k--){
          rec ans=query(1,1,n,l,r);
          if(ans.sl[0]>ans.sr[0] && ans.sl[0]>ans.s[0]){
            tot+=ans.sl[0];
            rev(1,1,n,l,ans.recl[0]);
            ql[++num]=l;qr[num]=ans.recl[0];
          }
          else
          if(ans.sr[0]>ans.s[0]){
            tot+=ans.sr[0];
            rev(1,1,n,ans.recr[0],r);
            ql[++num]=ans.recr[0];qr[num]=r;
          }
          else{
            tot+=ans.s[0];
            rev(1,1,n,ans.recll[0],ans.recrr[0]);
            ql[++num]=ans.recll[0];qr[num]=ans.recrr[0];
          }
          Ans=max(Ans,tot);
        }
        while(num)rev(1,1,n,ql[num],qr[num]),num--;
        printf("%d\n",Ans);
      }
    }
    return 0;
}


#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<cmath>
using namespace std;
#define N 110000
struct rec{
       int sum[2],sl[2],sr[2],s[2],recl[2],recr[2],recll[2],recrr[2];
       }tr[N*4];
int a[N],lab[N*4],ql[100],qr[100],n,Max=0;
rec merge(rec a,rec b){
    rec c;
    for(int k=0;k<=1;k++){
      c.sum[k]=a.sum[k]+b.sum[k];
      if(a.sl[k]>a.sum[k]+b.sl[k])c.sl[k]=a.sl[k],c.recl[k]=a.recl[k];
      else c.sl[k]=a.sum[k]+b.sl[k],c.recl[k]=b.recl[k];
      if(b.sr[k]>b.sum[k]+a.sr[k])c.sr[k]=b.sr[k],c.recr[k]=b.recr[k];
      else c.sr[k]=b.sum[k]+a.sr[k],c.recr[k]=a.recr[k];
      if(a.s[k]>b.s[k] && a.s[k]>a.sr[k]+b.sl[k])c.s[k]=a.s[k],c.recll[k]=a.recll[k],c.recrr[k]=a.recrr[k];
      else
      if(b.s[k]>a.sr[k]+b.sl[k])c.s[k]=b.s[k],c.recll[k]=b.recll[k],c.recrr[k]=b.recrr[k];
      else c.s[k]=a.sr[k]+b.sl[k],c.recll[k]=a.recr[k],c.recrr[k]=b.recl[k];
    }
    return c;
}
void down(int u,int l,int r){
     if(!lab[u])return;
     swap(tr[u].sum[0],tr[u].sum[1]);
     swap(tr[u].sl[0],tr[u].sl[1]);
     swap(tr[u].sr[0],tr[u].sr[1]);
     swap(tr[u].s[0],tr[u].s[1]);
     swap(tr[u].recl[0],tr[u].recl[1]);
     swap(tr[u].recr[0],tr[u].recr[1]);
     swap(tr[u].recll[0],tr[u].recll[1]);
     swap(tr[u].recrr[0],tr[u].recrr[1]);
     if(l!=r)lab[u*2]^=1,lab[u*2+1]^=1;
     lab[u]=0;
}
void debug(int u,int l,int r){
     printf("%d %d %d %d %d %d\n",l,r,tr[u].sl[0],tr[u].sr[0],tr[u].s[0],tr[u].sum[0]);
     }
void build(int u,int l,int r){
     if(l==r){
       Max=max(Max,u);
       tr[u].sum[0]=tr[u].sl[0]=tr[u].sr[0]=tr[u].s[0]=a[l];
       tr[u].sum[1]=tr[u].sl[1]=tr[u].sr[1]=tr[u].s[1]=-a[l];
       tr[u].recl[0]=tr[u].recl[1]=tr[u].recr[0]=tr[u].recr[1]=l;
       tr[u].recll[0]=tr[u].recll[1]=tr[u].recrr[0]=tr[u].recrr[1]=l;
     //  debug(u,l,r);
       return;
     }
     int mid=(l+r)/2;
     build(u*2,l,mid);
     build(u*2+1,mid+1,r);
     tr[u]=merge(tr[u*2],tr[u*2+1]);
   //  debug(u,l,r);
}
void change(int u,int l,int r,int x){
     down(u,l,r);
     if(l==r){
       tr[u].sum[0]=tr[u].sl[0]=tr[u].sr[0]=tr[u].s[0]=a[l];
       tr[u].sum[1]=tr[u].sl[1]=tr[u].sr[1]=tr[u].s[1]=-a[l];
       tr[u].recl[0]=tr[u].recl[1]=tr[u].recr[0]=tr[u].recr[1]=l;
       tr[u].recll[0]=tr[u].recll[1]=tr[u].recrr[0]=tr[u].recrr[1]=l;
       return;
     }
     int mid=(l+r)/2;
     if(x<=mid)change(u*2,l,mid,x);
     else change(u*2+1,mid+1,r,x);
     down(u*2,l,mid);down(u*2+1,mid+1,r);
     tr[u]=merge(tr[u*2],tr[u*2+1]);
}
rec query(int u,int l,int r,int x,int y){
    down(u,l,r);
    if(x<=l && y>=r)return tr[u];
    int mid=(l+r)/2;
    if(y<=mid)return query(u*2,l,mid,x,y);
    if(x>mid)return query(u*2+1,mid+1,r,x,y);
    return merge(query(u*2,l,mid,x,y),query(u*2+1,mid+1,r,x,y));
}
void rev(int u,int l,int r,int x,int y){
     down(u,l,r);
     if(x>r || y<l)return;
     if(x<=l && y>=r){
       lab[u]=1;
       down(u,l,r);
       return;
     }
     int mid=(l+r)/2;
     rev(u*2,l,mid,x,y);
     rev(u*2+1,mid+1,r,x,y);
     down(u*2,l,mid);down(u*2+1,mid+1,r);
     tr[u]=merge(tr[u*2],tr[u*2+1]);
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++)scanf("%d",&a[i]);
    build(1,1,n);
    int T;
    scanf("%d",&T);
    while(T--){
      int kk;
      scanf("%d",&kk);
      if(!kk){
        int x,y;
        scanf("%d%d",&x,&y);
        a[x]=y;
        change(1,1,n,x);
      }
      else{
        int l,r,k,Ans=0,tot=0,num=0;
        scanf("%d%d%d",&l,&r,&k);
        while(k--){
          rec ans=query(1,1,n,l,r);
          if(ans.sl[0]>ans.sr[0] && ans.sl[0]>ans.s[0]){
            tot+=ans.sl[0];
            rev(1,1,n,l,ans.recl[0]);
            ql[++num]=l;qr[num]=ans.recl[0];
          }
          else
          if(ans.sr[0]>ans.s[0]){
            tot+=ans.sr[0];
            rev(1,1,n,ans.recr[0],r);
            ql[++num]=ans.recr[0];qr[num]=r;
          }
          else{
            tot+=ans.s[0];
            rev(1,1,n,ans.recll[0],ans.recrr[0]);
            ql[++num]=ans.recll[0];qr[num]=ans.recrr[0];
          }
          Ans=max(Ans,tot);
        }
        while(num)rev(1,1,n,ql[num],qr[num]),num--;
        printf("%d\n",Ans);
      }
    }
    return 0;
}


#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<cmath>
using namespace std;
#define N 310000
struct rec{
       int sum[2],sl[2],sr[2],s[2],recl[2],recr[2],recll[2],recrr[2];
       }tr[N*4];
int a[N],lab[N],ql[100],qr[100],n;
rec merge(rec a,rec b){
    rec c;
    for(int k=0;k<=1;k++){
      c.sum[k]=a.sum[k]+b.sum[k];
      if(a.sl[k]>a.sum[k]+b.sl[k])c.sl[k]=a.sl[k],c.recl[k]=a.recl[k];
      else c.sl[k]=a.sum[k]+b.sl[k],c.recl[k]=b.recl[k];
      if(b.sr[k]>b.sum[k]+a.sr[k])c.sr[k]=b.sr[k],c.recr[k]=b.recr[k];
      else c.sr[k]=b.sum[k]+a.sr[k],c.recr[k]=a.recr[k];
      if(a.s[k]>b.s[k] && a.s[k]>a.sr[k]+b.sl[k])c.s[k]=a.s[k],c.recll[k]=a.recll[k],c.recrr[k]=a.recrr[k];
      else
      if(b.s[k]>a.sr[k]+b.sl[k])c.s[k]=b.s[k],c.recll[k]=b.recll[k],c.recrr[k]=b.recrr[k];
      else c.s[k]=a.sr[k]+b.sl[k],c.recll[k]=a.recr[k],c.recrr[k]=b.recl[k];
    }
    return c;
}
void down(int u,int l,int r){
     if(!lab[u])return;
     swap(tr[u].sum[0],tr[u].sum[1]);
     swap(tr[u].sl[0],tr[u].sl[1]);
     swap(tr[u].sr[0],tr[u].sr[1]);
     swap(tr[u].s[0],tr[u].s[1]);
     swap(tr[u].recl[0],tr[u].recl[1]);
     swap(tr[u].recr[0],tr[u].recr[1]);
     swap(tr[u].recll[0],tr[u].recll[1]);
     swap(tr[u].recrr[0],tr[u].recrr[1]);
     if(l!=r)lab[u*2]^=1,lab[u*2+1]^=1;
     lab[u]=0;
}
void debug(int u,int l,int r){
     printf("%d %d %d %d %d %d\n",l,r,tr[u].sl[0],tr[u].sr[0],tr[u].s[0],tr[u].sum[0]);
     }
void build(int u,int l,int r){
     if(l==r){
       tr[u].sum[0]=tr[u].sl[0]=tr[u].sr[0]=tr[u].s[0]=a[l];
       tr[u].sum[1]=tr[u].sl[1]=tr[u].sr[1]=tr[u].s[1]=-a[l];
       tr[u].recl[0]=tr[u].recl[1]=tr[u].recr[0]=tr[u].recr[1]=l;
       tr[u].recll[0]=tr[u].recll[1]=tr[u].recrr[0]=tr[u].recrr[1]=l;
     //  debug(u,l,r);
       return;
     }
     int mid=(l+r)/2;
     build(u*2,l,mid);
     build(u*2+1,mid+1,r);
     tr[u]=merge(tr[u*2],tr[u*2+1]);
   //  debug(u,l,r);
}
void change(int u,int l,int r,int x){
     down(u,l,r);
     if(l==r){
       tr[u].sum[0]=tr[u].sl[0]=tr[u].sr[0]=tr[u].s[0]=a[l];
       tr[u].sum[1]=tr[u].sl[1]=tr[u].sr[1]=tr[u].s[1]=-a[l];
       tr[u].recl[0]=tr[u].recl[1]=tr[u].recr[0]=tr[u].recr[1]=l;
       tr[u].recll[0]=tr[u].recll[1]=tr[u].recrr[0]=tr[u].recrr[1]=l;
       return;
     }
     int mid=(l+r)/2;
     if(x<=mid)change(u*2,l,mid,x);
     else change(u*2+1,mid+1,r,x);
     down(u*2,l,mid);down(u*2+1,mid+1,r);
     tr[u]=merge(tr[u*2],tr[u*2+1]);
}
rec query(int u,int l,int r,int x,int y){
    down(u,l,r);
    if(x<=l && y>=r)return tr[u];
    int mid=(l+r)/2;
    if(y<=mid)return query(u*2,l,mid,x,y);
    if(x>mid)return query(u*2+1,mid+1,r,x,y);
    return merge(query(u*2,l,mid,x,y),query(u*2+1,mid+1,r,x,y));
}
void rev(int u,int l,int r,int x,int y){
     down(u,l,r);
     if(x>r || y<l)return;
     if(x<=l && y>=r){
       lab[u]=1;
       down(u,l,r);
       return;
     }
     int mid=(l+r)/2;
     rev(u*2,l,mid,x,y);
     rev(u*2+1,mid+1,r,x,y);
     down(u*2,l,mid);down(u*2+1,mid+1,r);
     tr[u]=merge(tr[u*2],tr[u*2+1]);
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++)scanf("%d",&a[i]);
    build(1,1,n);
    int T;
    scanf("%d",&T);
    while(T--){
      int kk;
      scanf("%d",&kk);
      if(!kk){
        int x,y;
        scanf("%d%d",&x,&y);
        a[x]=y;
        change(1,1,n,x);
      }
      else{
        int l,r,k,Ans=0,tot=0,num=0;
        scanf("%d%d%d",&l,&r,&k);
        while(k--){
          rec ans=query(1,1,n,l,r);
          if(ans.sl[0]>ans.sr[0] && ans.sl[0]>ans.s[0]){
            tot+=ans.sl[0];
            rev(1,1,n,l,ans.recl[0]);
            ql[++num]=l;qr[num]=ans.recl[0];
          }
          else
          if(ans.sr[0]>ans.s[0]){
            tot+=ans.sr[0];
            rev(1,1,n,ans.recr[0],r);
            ql[++num]=ans.recr[0];qr[num]=r;
          }
          else{
            tot+=ans.s[0];
            rev(1,1,n,ans.recll[0],ans.recrr[0]);
            ql[++num]=ans.recll[0];qr[num]=ans.recrr[0];
          }
          Ans=max(Ans,tot);
        }
        while(num)rev(1,1,n,ql[num],qr[num]),num--;
        printf("%d\n",Ans);
      }
    }
    return 0;
}


#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<cmath>
using namespace std;
#define N 110000
struct rec{
       int sum[2],sl[2],sr[2],s[2],recl[2],recr[2],recll[2],recrr[2];
       }tr[N*4];
int a[N],lab[N],ql[100],qr[100],n;
rec merge(rec a,rec b){
    rec c;
    for(int k=0;k<=1;k++){
      c.sum[k]=a.sum[k]+b.sum[k];
      if(a.sl[k]>a.sum[k]+b.sl[k])c.sl[k]=a.sl[k],c.recl[k]=a.recl[k];
      else c.sl[k]=a.sum[k]+b.sl[k],c.recl[k]=b.recl[k];
      if(b.sr[k]>b.sum[k]+a.sr[k])c.sr[k]=b.sr[k],c.recr[k]=b.recr[k];
      else c.sr[k]=b.sum[k]+a.sr[k],c.recr[k]=a.recr[k];
      if(a.s[k]>b.s[k] && a.s[k]>a.sr[k]+b.sl[k])c.s[k]=a.s[k],c.recll[k]=a.recll[k],c.recrr[k]=a.recrr[k];
      else
      if(b.s[k]>a.sr[k]+b.sl[k])c.s[k]=b.s[k],c.recll[k]=b.recll[k],c.recrr[k]=b.recrr[k];
      else c.s[k]=a.sr[k]+b.sl[k],c.recll[k]=a.recr[k],c.recrr[k]=b.recl[k];
    }
    return c;
}
void down(int u,int l,int r){
     if(!lab[u])return;
     swap(tr[u].sum[0],tr[u].sum[1]);
     swap(tr[u].sl[0],tr[u].sl[1]);
     swap(tr[u].sr[0],tr[u].sr[1]);
     swap(tr[u].s[0],tr[u].s[1]);
     swap(tr[u].recl[0],tr[u].recl[1]);
     swap(tr[u].recr[0],tr[u].recr[1]);
     swap(tr[u].recll[0],tr[u].recll[1]);
     swap(tr[u].recrr[0],tr[u].recrr[1]);
     if(l!=r)lab[u*2]^=1,lab[u*2+1]^=1;
     lab[u]=0;
}
void debug(int u,int l,int r){
     printf("%d %d %d %d %d %d\n",l,r,tr[u].sl[0],tr[u].sr[0],tr[u].s[0],tr[u].sum[0]);
     }
void build(int u,int l,int r){
     if(l==r){
       tr[u].sum[0]=tr[u].sl[0]=tr[u].sr[0]=tr[u].s[0]=a[l];
       tr[u].sum[1]=tr[u].sl[1]=tr[u].sr[1]=tr[u].s[1]=-a[l];
       tr[u].recl[0]=tr[u].recl[1]=tr[u].recr[0]=tr[u].recr[1]=l;
       tr[u].recll[0]=tr[u].recll[1]=tr[u].recrr[0]=tr[u].recrr[1]=l;
     //  debug(u,l,r);
       return;
     }
     int mid=(l+r)/2;
     build(u*2,l,mid);
     build(u*2+1,mid+1,r);
     tr[u]=merge(tr[u*2],tr[u*2+1]);
   //  debug(u,l,r);
}
void change(int u,int l,int r,int x){
     down(u,l,r);
     if(l==r){
       tr[u].sum[0]=tr[u].sl[0]=tr[u].sr[0]=tr[u].s[0]=a[l];
       tr[u].sum[1]=tr[u].sl[1]=tr[u].sr[1]=tr[u].s[1]=-a[l];
       tr[u].recl[0]=tr[u].recl[1]=tr[u].recr[0]=tr[u].recr[1]=l;
       tr[u].recll[0]=tr[u].recll[1]=tr[u].recrr[0]=tr[u].recrr[1]=l;
       return;
     }
     int mid=(l+r)/2;
     if(x<=mid)change(u*2,l,mid,x);
     else change(u*2+1,mid+1,r,x);
     down(u*2,l,mid);down(u*2+1,mid+1,r);
     tr[u]=merge(tr[u*2],tr[u*2+1]);
}
rec query(int u,int l,int r,int x,int y){
    down(u,l,r);
    if(x<=l && y>=r)return tr[u];
    int mid=(l+r)/2;
    if(y<=mid)return query(u*2,l,mid,x,y);
    if(x>mid)return query(u*2+1,mid+1,r,x,y);
    return merge(query(u*2,l,mid,x,y),query(u*2+1,mid+1,r,x,y));
}
void rev(int u,int l,int r,int x,int y){
     down(u,l,r);
     if(x>r || y<l)return;
     if(x<=l && y>=r){
       lab[u]=1;
       down(u,l,r);
       return;
     }
     int mid=(l+r)/2;
     rev(u*2,l,mid,x,y);
     rev(u*2+1,mid+1,r,x,y);
     down(u*2,l,mid);down(u*2+1,mid+1,r);
     tr[u]=merge(tr[u*2],tr[u*2+1]);
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++)scanf("%d",&a[i]);
    build(1,1,n);
    int T;
    scanf("%d",&T);
    while(T--){
      int kk;
      scanf("%d",&kk);
      if(!kk){
        int x,y;
        scanf("%d%d",&x,&y);
        a[x]=y;
        change(1,1,n,x);
      }
      else{
        int l,r,k,Ans=0,tot=0,num=0;
        scanf("%d%d%d",&l,&r,&k);
        while(k--){
          rec ans=query(1,1,n,l,r);
          if(ans.sl[0]>ans.sr[0] && ans.sl[0]>ans.s[0]){
            tot+=ans.sl[0];
            rev(1,1,n,l,ans.recl[0]);
            ql[++num]=l;qr[num]=ans.recl[0];
          }
          else
          if(ans.sr[0]>ans.s[0]){
            tot+=ans.sr[0];
            rev(1,1,n,ans.recr[0],r);
            ql[++num]=ans.recr[0];qr[num]=r;
          }
          else{
            tot+=ans.s[0];
            rev(1,1,n,ans.recll[0],ans.recrr[0]);
            ql[++num]=ans.recll[0];qr[num]=ans.recrr[0];
          }
          Ans=max(Ans,tot);
        }
        while(num)rev(1,1,n,ql[num],qr[num]),num--;
        printf("%d\n",Ans);
      }
    }
    return 0;
}


#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<cmath>
using namespace std;
#define N 210000
struct rec{
       int sum[2],sl[2],sr[2],s[2],recl[2],recr[2],recll[2],recrr[2];
       }tr[N*4];
int a[N],lab[N],ql[100],qr[100],n;
rec merge(rec a,rec b){
    rec c;
    for(int k=0;k<=1;k++){
      c.sum[k]=a.sum[k]+b.sum[k];
      if(a.sl[k]>a.sum[k]+b.sl[k])c.sl[k]=a.sl[k],c.recl[k]=a.recl[k];
      else c.sl[k]=a.sum[k]+b.sl[k],c.recl[k]=b.recl[k];
      if(b.sr[k]>b.sum[k]+a.sr[k])c.sr[k]=b.sr[k],c.recr[k]=b.recr[k];
      else c.sr[k]=b.sum[k]+a.sr[k],c.recr[k]=a.recr[k];
      if(a.s[k]>b.s[k] && a.s[k]>a.sr[k]+b.sl[k])c.s[k]=a.s[k],c.recll[k]=a.recll[k],c.recrr[k]=a.recrr[k];
      else
      if(b.s[k]>a.sr[k]+b.sl[k])c.s[k]=b.s[k],c.recll[k]=b.recll[k],c.recrr[k]=b.recrr[k];
      else c.s[k]=a.sr[k]+b.sl[k],c.recll[k]=a.recr[k],c.recrr[k]=b.recl[k];
    }
    return c;
}
void down(int u,int l,int r){
     if(!lab[u])return;
     swap(tr[u].sum[0],tr[u].sum[1]);
     swap(tr[u].sl[0],tr[u].sl[1]);
     swap(tr[u].sr[0],tr[u].sr[1]);
     swap(tr[u].s[0],tr[u].s[1]);
     swap(tr[u].recl[0],tr[u].recl[1]);
     swap(tr[u].recr[0],tr[u].recr[1]);
     swap(tr[u].recll[0],tr[u].recll[1]);
     swap(tr[u].recrr[0],tr[u].recrr[1]);
     if(l!=r)lab[u*2]^=1,lab[u*2+1]^=1;
     lab[u]=0;
}
void debug(int u,int l,int r){
     printf("%d %d %d %d %d %d\n",l,r,tr[u].sl[0],tr[u].sr[0],tr[u].s[0],tr[u].sum[0]);
     }
void build(int u,int l,int r){
     if(l==r){
       tr[u].sum[0]=tr[u].sl[0]=tr[u].sr[0]=tr[u].s[0]=a[l];
       tr[u].sum[1]=tr[u].sl[1]=tr[u].sr[1]=tr[u].s[1]=-a[l];
       tr[u].recl[0]=tr[u].recl[1]=tr[u].recr[0]=tr[u].recr[1]=l;
       tr[u].recll[0]=tr[u].recll[1]=tr[u].recrr[0]=tr[u].recrr[1]=l;
     //  debug(u,l,r);
       return;
     }
     int mid=(l+r)/2;
     build(u*2,l,mid);
     build(u*2+1,mid+1,r);
     tr[u]=merge(tr[u*2],tr[u*2+1]);
   //  debug(u,l,r);
}
void change(int u,int l,int r,int x){
     down(u,l,r);
     if(l==r){
       tr[u].sum[0]=tr[u].sl[0]=tr[u].sr[0]=tr[u].s[0]=a[l];
       tr[u].sum[1]=tr[u].sl[1]=tr[u].sr[1]=tr[u].s[1]=-a[l];
       tr[u].recl[0]=tr[u].recl[1]=tr[u].recr[0]=tr[u].recr[1]=l;
       tr[u].recll[0]=tr[u].recll[1]=tr[u].recrr[0]=tr[u].recrr[1]=l;
       return;
     }
     int mid=(l+r)/2;
     if(x<=mid)change(u*2,l,mid,x);
     else change(u*2+1,mid+1,r,x);
     down(u*2,l,mid);down(u*2+1,mid+1,r);
     tr[u]=merge(tr[u*2],tr[u*2+1]);
}
rec query(int u,int l,int r,int x,int y){
    down(u,l,r);
    if(x<=l && y>=r)return tr[u];
    int mid=(l+r)/2;
    if(y<=mid)return query(u*2,l,mid,x,y);
    if(x>mid)return query(u*2+1,mid+1,r,x,y);
    return merge(query(u*2,l,mid,x,y),query(u*2+1,mid+1,r,x,y));
}
void rev(int u,int l,int r,int x,int y){
     down(u,l,r);
     if(x>r || y<l)return;
     if(x<=l && y>=r){
       lab[u]=1;
       down(u,l,r);
       return;
     }
     int mid=(l+r)/2;
     rev(u*2,l,mid,x,y);
     rev(u*2+1,mid+1,r,x,y);
     down(u*2,l,mid);down(u*2+1,mid+1,r);
     tr[u]=merge(tr[u*2],tr[u*2+1]);
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++)scanf("%d",&a[i]);
    build(1,1,n);
    int T;
    scanf("%d",&T);
    while(T--){
      int kk;
      scanf("%d",&kk);
      if(!kk){
        int x,y;
        scanf("%d%d",&x,&y);
        a[x]=y;
        change(1,1,n,x);
      }
      else{
        int l,r,k,Ans=0,tot=0,num=0;
        scanf("%d%d%d",&l,&r,&k);
        while(k--){
          rec ans=query(1,1,n,l,r);
          if(ans.sl[0]>ans.sr[0] && ans.sl[0]>ans.s[0]){
            tot+=ans.sl[0];
            rev(1,1,n,l,ans.recl[0]);
            ql[++num]=l;qr[num]=ans.recl[0];
          }
          else
          if(ans.sr[0]>ans.s[0]){
            tot+=ans.sr[0];
            rev(1,1,n,ans.recr[0],r);
            ql[++num]=ans.recr[0];qr[num]=r;
          }
          else{
            tot+=ans.s[0];
            rev(1,1,n,ans.recll[0],ans.recrr[0]);
            ql[++num]=ans.recll[0];qr[num]=ans.recrr[0];
          }
          Ans=max(Ans,tot);
        }
        while(num)rev(1,1,n,ql[num],qr[num]),num--;
        printf("%d\n",Ans);
      }
    }
    return 0;
}


#include<cstdio>
#include<cstring>
#include<algorithm>
#define MaxN 100010
using namespace std;
struct Node{
    int pre[2][2],prepos[2][2],ans[2],anspos[2][2],sum,is;
}Tree[MaxN*4],stack[MaxN];
int N,M,A[MaxN],Son[MaxN*4][2];
Node trans(Node a){
    if(!a.is)
        return a;
    int i,j;
    a.sum=-a.sum;
    for(i=0;i<2;++i){
        swap(a.pre[0][i],a.pre[1][i]);
        swap(a.prepos[0][i],a.prepos[1][i]);
        swap(a.anspos[0][i],a.anspos[1][i]);
    }
    for(i=0;i<2;++i)
        for(j=0;j<2;++j)
            a.pre[i][j]=-a.pre[i][j];
    swap(a.ans[0],a.ans[1]);
    a.ans[0]=-a.ans[0];
    a.ans[1]=-a.ans[1];
    return a;
}
void Down(int S){
    if(!Tree[S].is) return;
    Tree[S]=trans(Tree[S]);
    Tree[S].is=0;
    if(Son[S][0]==Son[S][1])
        return;
    Tree[S*2].is^=1;
    Tree[S*2+1].is^=1;
}
Node MainTain(Node a,Node b){
    Node ret,pp[2];
    ret.is=0;
    pp[0]=a;pp[1]=b;
    ret.sum=a.sum+b.sum;
    for(int i=0;i<2;++i)
        for(int j=0;j<2;++j){
            int det=i==0?1:-1;
            if(pp[j].pre[i][j]*det>(pp[j].sum+pp[j^1].pre[i][j])*det){
                ret.pre[i][j]=pp[j].pre[i][j];
                ret.prepos[i][j]=pp[j].prepos[i][j];
            }
            else{
                ret.pre[i][j]=pp[j].sum+pp[j^1].pre[i][j];
                ret.prepos[i][j]=pp[j^1].prepos[i][j];
            }
        }
    for(int i=0;i<2;++i){
        ret.ans[i]=a.ans[i];ret.anspos[i][0]=a.anspos[i][0];ret.anspos[i][1]=a.anspos[i][1];
        int det=i==0?1:-1;
        if(det*ret.ans[i]<det*b.ans[i]){
            ret.ans[i]=b.ans[i];ret.anspos[i][0]=b.anspos[i][0];ret.anspos[i][1]=b.anspos[i][1];
        }
        if(det*ret.ans[i]<det*(a.pre[i][1]+b.pre[i][0])){
            ret.ans[i]=a.pre[i][1]+b.pre[i][0];
            ret.anspos[i][0]=a.prepos[i][1];ret.anspos[i][1]=b.prepos[i][0];
        }
    }
    return ret;
}
void BuildTree(int S,int l,int r){
    Tree[S].is=0;
    Son[S][0]=l;Son[S][1]=r;
    if(l==r){
        for(int i=0;i<2;++i)
            for(int j=0;j<2;++j){
                Tree[S].pre[i][j]=A[l];
                Tree[S].prepos[i][j]=l;
                Tree[S].anspos[i][j]=l;
            }
        Tree[S].ans[0]=Tree[S].ans[1]=A[l];
        Tree[S].sum=A[l];
        return;
    }
    BuildTree(S*2,l,l+r>>1);
    BuildTree(S*2+1,l+r+2>>1,r);
    Tree[S]=MainTain(Tree[S*2],Tree[S*2+1]);
    //printf("%d %d %d %d\n",l,r,Tree[S].ans[0],Tree[S].ans[1]);
}
void Modify(int S,int l,int val){
    Down(S);
    if(Son[S][0]==Son[S][1]){
        A[l]=val;
        for(int i=0;i<2;++i)
            for(int j=0;j<2;++j){
                Tree[S].pre[i][j]=A[l];
                Tree[S].prepos[i][j]=l;
                Tree[S].anspos[i][j]=l;
            }
        Tree[S].ans[0]=Tree[S].ans[1]=A[l];
        Tree[S].sum=A[l];
        return;
    }
    if(l<=Son[S*2][1])
        Modify(S*2,l,val);
    else
        Modify(S*2+1,l,val);
    Tree[S]=MainTain(trans(Tree[S*2]),trans(Tree[S*2+1]));
}
void Modify_Swap(int S,int l,int r){
    Down(S);
    if(l<=Son[S][0]&&Son[S][1]<=r){
        Tree[S].is^=1;
        return;
    }
    if(l<=Son[S*2][1])
        Modify_Swap(S*2,l,r);
    if(r>=Son[S*2+1][0])
        Modify_Swap(S*2+1,l,r);
    Tree[S]=MainTain(trans(Tree[S*2]),trans(Tree[S*2+1]));
}
Node Query(int S,int l,int r){
    Down(S);
    if(l<=Son[S][0]&&Son[S][1]<=r){
        if(Son[S][0]!=Son[S][1])
            Tree[S]=MainTain(trans(Tree[S*2]),trans(Tree[S*2+1]));
        else{
            Tree[S]=trans(Tree[S]);
        }
        return Tree[S];
    }
    Node ret;
    if(r<=Son[S*2][1])
        ret=Query(S*2,l,r);
    if(l>=Son[S*2+1][0])
        ret=Query(S*2+1,l,r);
    if(l<=Son[S*2][1]&&Son[S*2+1][0]<=r){
        ret=Query(S*2,l,r);
        ret=MainTain(ret,Query(S*2+1,l,r));
    }
    Tree[S]=MainTain(trans(Tree[S*2]),trans(Tree[S*2+1]));
    return ret;
}
int main(){
    int i,j,ll;
    scanf("%d",&N);
    for(i=1;i<=N;++i)scanf("%d",&A[i]);
    BuildTree(1,1,N);
    scanf("%d",&M);
    int cas,l,r,k,val;
    for(i=1;i<=M;++i){
        scanf("%d",&cas);
        if(!cas){
            scanf("%d%d",&l,&val);
            Modify(1,l,val);
        }
        else{
            scanf("%d%d%d",&l,&r,&k);
            int nowans=0,flag=0;
            for(j=1;j<=k;++j){
                stack[j]=Query(1,l,r);
                if(stack[j].ans[0]<=0)
                    break;
                nowans+=stack[j].ans[0];
                Modify_Swap(1,stack[j].anspos[0][0],stack[j].anspos[0][1]);
            }
            for(ll=1;ll<j;++ll)
                Modify_Swap(1,stack[ll].anspos[0][0],stack[ll].anspos[0][1]);
            printf("%d\n",nowans);
        }
    }
    return 0;
}


#include<cstdio>
#include<cstring>
#include<algorithm>
#define MaxN 400010
using namespace std;
struct Node{
    int pre[2][2],prepos[2][2],ans[2],anspos[2][2],sum,is;
}Tree[MaxN*4],stack[MaxN];
bool stateflag=0;
Node state;
int N,M,A[MaxN],Son[MaxN*4][2];
Node trans(Node a){
    if(!a.is)
        return a;
    int i,j;
    a.sum=-a.sum;
    for(i=0;i<2;++i){
        swap(a.pre[0][i],a.pre[1][i]);
        swap(a.prepos[0][i],a.prepos[1][i]);
        swap(a.anspos[0][i],a.anspos[1][i]);
    }
    for(i=0;i<2;++i)
        for(j=0;j<2;++j)
            a.pre[i][j]=-a.pre[i][j];
    swap(a.ans[0],a.ans[1]);
    a.ans[0]=-a.ans[0];
    a.ans[1]=-a.ans[1];
    return a;
}
void Down(int S){
    if(!Tree[S].is) return;
    Tree[S]=trans(Tree[S]);
    Tree[S].is=0;
    if(Son[S][0]==Son[S][1])
        return;
    Tree[S*2].is^=1;
    Tree[S*2+1].is^=1;
}
Node MainTain(Node a,Node b){
    Node ret,pp[2];
    ret.is=0;
    pp[0]=a;pp[1]=b;
    ret.sum=a.sum+b.sum;
    for(int i=0;i<2;++i)
        for(int j=0;j<2;++j){
            int det=i==0?1:-1;
            if(pp[j].pre[i][j]*det>(pp[j].sum+pp[j^1].pre[i][j])*det){
                ret.pre[i][j]=pp[j].pre[i][j];
                ret.prepos[i][j]=pp[j].prepos[i][j];
            }
            else{
                ret.pre[i][j]=pp[j].sum+pp[j^1].pre[i][j];
                ret.prepos[i][j]=pp[j^1].prepos[i][j];
            }
        }
    for(int i=0;i<2;++i){
        ret.ans[i]=a.ans[i];ret.anspos[i][0]=a.anspos[i][0];ret.anspos[i][1]=a.anspos[i][1];
        int det=i==0?1:-1;
        if(det*ret.ans[i]<det*b.ans[i]){
            ret.ans[i]=b.ans[i];ret.anspos[i][0]=b.anspos[i][0];ret.anspos[i][1]=b.anspos[i][1];
        }
        if(det*ret.ans[i]<det*(a.pre[i][1]+b.pre[i][0])){
            ret.ans[i]=a.pre[i][1]+b.pre[i][0];
            ret.anspos[i][0]=a.prepos[i][1];ret.anspos[i][1]=b.prepos[i][0];
        }
    }
    return ret;
}
void BuildTree(int S,int l,int r){
    Tree[S].is=0;
    Son[S][0]=l;Son[S][1]=r;
    if(l==r){
        for(int i=0;i<2;++i)
            for(int j=0;j<2;++j){
                Tree[S].pre[i][j]=A[l];
                Tree[S].prepos[i][j]=l;
                Tree[S].anspos[i][j]=l;
            }
        Tree[S].ans[0]=Tree[S].ans[1]=A[l];
        Tree[S].sum=A[l];
        return;
    }
    BuildTree(S*2,l,l+r>>1);
    BuildTree(S*2+1,l+r+2>>1,r);
    Tree[S]=MainTain(Tree[S*2],Tree[S*2+1]);
}
void Modify(int S,int l,int val){
    Down(S);
    if(Son[S][0]==Son[S][1]){
        A[l]=val;
        for(int i=0;i<2;++i)
            for(int j=0;j<2;++j){
                Tree[S].pre[i][j]=A[l];
                Tree[S].prepos[i][j]=l;
                Tree[S].anspos[i][j]=l;
            }
        Tree[S].ans[0]=Tree[S].ans[1]=A[l];
        Tree[S].sum=A[l];
        return;
    }
    if(l<=Son[S*2][1])
        Modify(S*2,l,val);
    else
        Modify(S*2+1,l,val);
    Tree[S]=MainTain(trans(Tree[S*2]),trans(Tree[S*2+1]));
}
void Modify_Swap(int S,int l,int r){
    Down(S);
    if(l<=Son[S][0]&&Son[S][1]<=r){
        Tree[S].is^=1;
        return;
    }
    if(l<=Son[S*2][1])
        Modify_Swap(S*2,l,r);
    if(r>=Son[S*2+1][0])
        Modify_Swap(S*2+1,l,r);
    Tree[S]=MainTain(trans(Tree[S*2]),trans(Tree[S*2+1]));
}
void Query(int S,int l,int r){
    Down(S);
    if(l<=Son[S][0]&&Son[S][1]<=r){
        if(!stateflag)
            state=Tree[S];
        if(Son[S][0]!=Son[S][1])
            Tree[S]=MainTain(trans(Tree[S*2]),trans(Tree[S*2+1]));
        else{
            Tree[S]=trans(Tree[S]);
        }
        if(!stateflag){
            state=Tree[S];
            //stateflag=1;
        }
        else
            state=MainTain(state,Tree[S]);
        return;
    }
    if(l<=Son[S*2][1])
        Query(S*2,l,r);
    if(r>=Son[S*2+1][0])
        Query(S*2+1,l,r);
    Tree[S]=MainTain(trans(Tree[S*2]),trans(Tree[S*2+1]));
}
int main(){
    int i,j,ll;
    scanf("%d",&N);
    for(i=1;i<=N;++i)scanf("%d",&A[i]);
    BuildTree(1,1,N);
    scanf("%d",&M);
    int cas,l,r,k,val;
    for(i=1;i<=M;++i){
        scanf("%d",&cas);
        if(!cas){
            scanf("%d%d",&l,&val);
            Modify(1,l,val);
        }
        else{
            scanf("%d%d%d",&l,&r,&k);
            int nowans=0,flag=0;
            for(j=1;j<=k;++j){
                stateflag=0;
                Query(1,l,r);
                stack[j]=state;
                if(stack[j].ans[0]<=0)
                    break;
                nowans+=stack[j].ans[0];
                Modify_Swap(1,stack[j].anspos[0][0],stack[j].anspos[0][1]);
            }
            for(ll=1;ll<j;++ll)
                Modify_Swap(1,stack[ll].anspos[0][0],stack[ll].anspos[0][1]);
            printf("%d\n",nowans);
        }
    }
    return 0;
}


#include<cstdio>
#include<cstring>
#include<algorithm>
#define MaxN 400010
using namespace std;
struct Node{
    int pre[2][2],prepos[2][2],ans[2],anspos[2][2],sum,is;
}Tree[MaxN*4],stack[MaxN];
bool stateflag=0;
Node state;
int N,M,A[MaxN],Son[MaxN*4][2];
Node trans(Node a){
    if(!a.is)
        return a;
    int i,j;
    a.sum=-a.sum;
    for(i=0;i<2;++i){
        swap(a.pre[0][i],a.pre[1][i]);
        swap(a.prepos[0][i],a.prepos[1][i]);
        swap(a.anspos[0][i],a.anspos[1][i]);
    }
    for(i=0;i<2;++i)
        for(j=0;j<2;++j)
            a.pre[i][j]=-a.pre[i][j];
    swap(a.ans[0],a.ans[1]);
    a.ans[0]=-a.ans[0];
    a.ans[1]=-a.ans[1];
    return a;
}
void Down(int S){
    if(!Tree[S].is) return;
    Tree[S]=trans(Tree[S]);
    Tree[S].is=0;
    if(Son[S][0]==Son[S][1])
        return;
    Tree[S*2].is^=1;
    Tree[S*2+1].is^=1;
}
Node MainTain(Node a,Node b){
    Node ret,pp[2];
    ret.is=0;
    pp[0]=a;pp[1]=b;
    ret.sum=a.sum+b.sum;
    for(int i=0;i<2;++i)
        for(int j=0;j<2;++j){
            int det=i==0?1:-1;
            if(pp[j].pre[i][j]*det>(pp[j].sum+pp[j^1].pre[i][j])*det){
                ret.pre[i][j]=pp[j].pre[i][j];
                ret.prepos[i][j]=pp[j].prepos[i][j];
            }
            else{
                ret.pre[i][j]=pp[j].sum+pp[j^1].pre[i][j];
                ret.prepos[i][j]=pp[j^1].prepos[i][j];
            }
        }
    for(int i=0;i<2;++i){
        ret.ans[i]=a.ans[i];ret.anspos[i][0]=a.anspos[i][0];ret.anspos[i][1]=a.anspos[i][1];
        int det=i==0?1:-1;
        if(det*ret.ans[i]<det*b.ans[i]){
            ret.ans[i]=b.ans[i];ret.anspos[i][0]=b.anspos[i][0];ret.anspos[i][1]=b.anspos[i][1];
        }
        if(det*ret.ans[i]<det*(a.pre[i][1]+b.pre[i][0])){
            ret.ans[i]=a.pre[i][1]+b.pre[i][0];
            ret.anspos[i][0]=a.prepos[i][1];ret.anspos[i][1]=b.prepos[i][0];
        }
    }
    return ret;
}
void BuildTree(int S,int l,int r){
    Tree[S].is=0;
    Son[S][0]=l;Son[S][1]=r;
    if(l==r){
        for(int i=0;i<2;++i)
            for(int j=0;j<2;++j){
                Tree[S].pre[i][j]=A[l];
                Tree[S].prepos[i][j]=l;
                Tree[S].anspos[i][j]=l;
            }
        Tree[S].ans[0]=Tree[S].ans[1]=A[l];
        Tree[S].sum=A[l];
        return;
    }
    BuildTree(S*2,l,l+r>>1);
    BuildTree(S*2+1,l+r+2>>1,r);
    Tree[S]=MainTain(Tree[S*2],Tree[S*2+1]);
}
void Modify(int S,int l,int val){
    Down(S);
    if(Son[S][0]==Son[S][1]){
        A[l]=val;
        for(int i=0;i<2;++i)
            for(int j=0;j<2;++j){
                Tree[S].pre[i][j]=A[l];
                Tree[S].prepos[i][j]=l;
                Tree[S].anspos[i][j]=l;
            }
        Tree[S].ans[0]=Tree[S].ans[1]=A[l];
        Tree[S].sum=A[l];
        return;
    }
    if(l<=Son[S*2][1])
        Modify(S*2,l,val);
    else
        Modify(S*2+1,l,val);
    Tree[S]=MainTain(trans(Tree[S*2]),trans(Tree[S*2+1]));
}
void Modify_Swap(int S,int l,int r){
    Down(S);
    if(l<=Son[S][0]&&Son[S][1]<=r){
        Tree[S].is^=1;
        return;
    }
    if(l<=Son[S*2][1])
        Modify_Swap(S*2,l,r);
    if(r>=Son[S*2+1][0])
        Modify_Swap(S*2+1,l,r);
    Tree[S]=MainTain(trans(Tree[S*2]),trans(Tree[S*2+1]));
}
void Query(int S,int l,int r){
    Down(S);
    if(l<=Son[S][0]&&Son[S][1]<=r){
        if(!stateflag)
            state=Tree[S];
        if(Son[S][0]!=Son[S][1])
            Tree[S]=MainTain(trans(Tree[S*2]),trans(Tree[S*2+1]));
        else{
            Tree[S]=trans(Tree[S]);
        }
        if(!stateflag){
            state=Tree[S];
            stateflag=1;
        }
        else
            state=MainTain(state,Tree[S]);
        return;
    }
    if(l<=Son[S*2][1])
        Query(S*2,l,r);
    if(r>=Son[S*2+1][0])
        Query(S*2+1,l,r);
    Tree[S]=MainTain(trans(Tree[S*2]),trans(Tree[S*2+1]));
}
int main(){
    //freopen("kmax6.in","r",stdin);
    //freopen("kmax6.out","w",stdout);
    int i,j,ll;
    scanf("%d",&N);
    for(i=1;i<=N;++i)scanf("%d",&A[i]);
    BuildTree(1,1,N);
    scanf("%d",&M);
    int cas,l,r,k,val;
    for(i=1;i<=M;++i){
        scanf("%d",&cas);
        if(!cas){
            scanf("%d%d",&l,&val);
            Modify(1,l,val);
        }
        else{
            scanf("%d%d%d",&l,&r,&k);
            int nowans=0,flag=0;
            for(j=1;j<=k;++j){
                stateflag=0;
                Query(1,l,r);
                stack[j]=state;
                if(stack[j].ans[0]<=0)
                    break;
                nowans+=stack[j].ans[0];
                Modify_Swap(1,stack[j].anspos[0][0],stack[j].anspos[0][1]);
            }
            for(ll=1;ll<j;++ll)
                Modify_Swap(1,stack[ll].anspos[0][0],stack[ll].anspos[0][1]);
            printf("%d\n",nowans);
        }
    }
    return 0;
}