import sys
input = sys.stdin.readline
#N,Q=map(int,input().split())
N=int(input())
mod=998244353
class lazy_segtree():
    def update(self,k):self.d[k]=self.op(self.d[2*k],self.d[2*k+1])
    def all_apply(self,k,f):
        self.d[k]=self.mapping(f,self.d[k])
        if (k<self.size):self.lz[k]=self.composition(f,self.lz[k])
    def push(self,k):
        self.all_apply(2*k,self.lz[k])
        self.all_apply(2*k+1,self.lz[k])
        self.lz[k]=self.identity
    def __init__(self,V,OP,E,MAPPING,COMPOSITION,ID):
        self.n=len(V)
        self.log=(self.n-1).bit_length()
        self.size=1<<self.log
        self.d=[E for i in range(2*self.size)]
        self.lz=[ID for i in range(self.size)]
        
        self.e=E
        self.op=OP
        self.mapping=MAPPING
        self.composition=COMPOSITION
        self.identity=ID
        for i in range(self.n):self.d[self.size+i]=V[i]
        for i in range(self.size-1,0,-1):self.update(i)

        
    def set(self,p,x):
        assert 0<=p and p<self.n
        p+=self.size
        for i in range(self.log,0,-1):self.push(p>>i)
        self.d[p]=x
        for i in range(1,self.log+1):self.update(p>>i)
    def get(self,p):
        assert 0<=p and p<self.n
        p+=self.size
        for i in range(self.log,0,-1):self.push(p>>i)
        return self.d[p]
    def prod(self,l,r):
        assert 0<=l and l<=r and r<=self.n
        if l==r:return self.e
        l+=self.size
        r+=self.size
        
        for i in range(self.log,0,-1):
            if (((l>>i)<<i)!=l):self.push(l>>i)
            if (((r>>i)<<i)!=r):self.push(r>>i)
        sml,smr=self.e,self.e
        #print(l,r,sml,smr)
        #print(self.d)
        #print(l,r,'!!!!',self.d[8])
        while(l<r):
            if l&1:
                #print(sml,'pre=============')
                #print(l,sml,self.d[l])
                sml=self.op(sml,self.d[l])             
                #print(sml,'!!')
                l+=1
            if r&1:
                r-=1
                #print(smr,'pre===============')
                #print(r,self.d[r],smr)
                smr=self.op(self.d[r],smr)
                #print(smr,'!!')
            l>>=1
            r>>=1
        return self.op(sml,smr)

    def apply(self,l,r,f):
        assert 0<=l and l<=r and r<=self.n
        if l==r:return
        l+=self.size
        r+=self.size
        for i in range(self.log,0,-1):
            if (((l>>i)<<i)!=l):self.push(l>>i)
            if (((r>>i)<<i)!=r):self.push((r-1)>>i)
        l2,r2=l,r
        while(l<r):
            if (l&1):
                self.all_apply(l,f)
                l+=1
            if (r&1):
                r-=1
                self.all_apply(r,f)
            l>>=1
            r>>=1
        l,r=l2,r2
        for i in range(1,self.log+1):
            if (((l>>i)<<i)!=l):self.update(l>>i)
            if (((r>>i)<<i)!=r):self.update((r-1)>>i)
    
    
# 更新 と 取得
# 最初の V -> 更新 f を行った後の 状態を mapping に定義 -> operate によって取得

# 今回は、値, 区間の長さを持たせたらうまく行きそう
# f(l, r) と r - l
# op : S[l, m) と S[m, r) を引数として S[l, r) を求める関数
# e  : 区間長 0 の区間に対応する情報
# mapping : 更新クエリ f を A[l, r) に対応させた後の S[l, r) を表す
# composition : 更新クエリ g, f をこの順で同じ区間に適応させることを 1 つの更新クエリとした際のものを表す
# id : 恒等写像を表す更新クエリ、すなわち何もしないクエリ 更新する値として取りえない値を取れば良い
DD={};c=0;EE={}
for i in range(1,5):
  for j in range(1,5):
    if i<=j:
      DD[(i,j)]=c 
      EE[c]=(i,j)
      c+=1

def operate(A,B):
    # 0 : 値、 1 : 区間の長さ
    C=[0]*11
    for i in range(10):
      for j in range(10):
        l,r=EE[i];p,q=EE[j]
        if r<=p:
          s=DD[(l,q)]
          #print((l,r),(p,q),(l,q),A[i],B[j],s)
          #print(C)
          C[s]=max(C[s],A[i]+B[j])
          #print(C)
          #print('___________________')
    C[-1]=A[-1]+B[-1]
    return C
  
# 更新クエリ f を各ノードが持つ data の値 x に対して作用させる関数
def mapping(f,x):
    if f==-1:
      return x
    ll=x[-1]
    C=[0]*11
    C[-1]=ll 
    for i in range(10):
      l,r=EE[i]
      if l<=f<=r:
        C[i]=ll
    return C

# 更新クエリ g,f をこの順で同じ区間に適応させることを 1 つの更新クエリとした際のものを表すもの
def composition(f,g):
  if f==-1:
    return g
  return f

e=[0]*11
C=[]
for i in range(1,5):
  D=[0]*11
  D[-1]=1
  for l,r in DD:
    if l<=i<=r:
      D[DD[(l,r)]]=1
  C.append(D)

id = -1
A=list(map(int, input().split()))
n=N
L=[]
# V,OP,E,MAPPING,COMPOSITION,ID
for a in A:
  L.append(C[a-1])
seg=lazy_segtree(L,operate,e,mapping,composition,id)

  
Q=int(input())
for _ in range(Q):
  B=list(map(int, input().split()))
  if B[0]==1:
    _,l,r=B
    l-=1
    ans=0
    AA=seg.prod(l,r)
    for i in range(10):
      ans=max(ans,AA[i])
    print(ans)
  else:
    _,l,r,x=B
    seg.apply(l-1,r,x)
  #print(seg.all_prod())