You've got an array *a*, consisting of *n* integers *a*<sub class="lower-index">1</sub>, *a*<sub class="lower-index">2</sub>, ..., *a*<sub class="lower-index">*n*</sub>. You are allowed to perform two operations on this array:
 1.  Calculate the sum of current array elements on the segment [*l*, *r*], that is, count value *a*<sub class="lower-index">*l*</sub> + *a*<sub class="lower-index">*l* + 1</sub> + ... + *a*<sub class="lower-index">*r*</sub>. 1.  Apply the xor operation with a given number *x* to each array element on the segment [*l*, *r*], that is, execute <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/2ef04d094daf2dcff9a998a558bd9cab93bbd012.png" style="max-width: 100.0%;max-height: 100.0%;"/>. This operation changes exactly *r* - *l* + 1 array elements. 
Expression <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/b364f2e04c665b78b924ec10666327a4ef4635bc.png" style="max-width: 100.0%;max-height: 100.0%;"/> means applying bitwise xor operation to numbers *x* and *y*. The given operation exists in all modern programming languages, for example in language C++ and Java it is marked as "^", in Pascal — as "xor".

You've got a list of *m* operations of the indicated type. Your task is to perform all given operations, for each sum query you should print the result you get.
The first line contains integer *n* (1 ≤ *n* ≤ 10<sup class="upper-index">5</sup>) — the size of the array. The second line contains space-separated integers *a*<sub class="lower-index">1</sub>, *a*<sub class="lower-index">2</sub>, ..., *a*<sub class="lower-index">*n*</sub> (0 ≤ *a*<sub class="lower-index">*i*</sub> ≤ 10<sup class="upper-index">6</sup>) — the original array.

The third line contains integer *m* (1 ≤ *m* ≤ 5·10<sup class="upper-index">4</sup>) — the number of operations with the array. The *i*-th of the following *m* lines first contains an integer *t*<sub class="lower-index">*i*</sub> (1 ≤ *t*<sub class="lower-index">*i*</sub> ≤ 2) — the type of the *i*-th query. If *t*<sub class="lower-index">*i*</sub> = 1, then this is the query of the sum, if *t*<sub class="lower-index">*i*</sub> = 2, then this is the query to change array elements. If the *i*-th operation is of type 1, then next follow two integers *l*<sub class="lower-index">*i*</sub>, *r*<sub class="lower-index">*i*</sub> (1 ≤ *l*<sub class="lower-index">*i*</sub> ≤ *r*<sub class="lower-index">*i*</sub> ≤ *n*). If the *i*-th operation is of type 2, then next follow three integers *l*<sub class="lower-index">*i*</sub>, *r*<sub class="lower-index">*i*</sub>, *x*<sub class="lower-index">*i*</sub> (1 ≤ *l*<sub class="lower-index">*i*</sub> ≤ *r*<sub class="lower-index">*i*</sub> ≤ *n*, 1 ≤ *x*<sub class="lower-index">*i*</sub> ≤ 10<sup class="upper-index">6</sup>). The numbers on the lines are separated by single spaces.
l=int(input())
arr=list(map(int,input().split(' '))) #[4,10,3,13,7] 

class Node:
    def __init__(self,sum,xor) -> None:
        self.sum=sum
        self.xor=xor

segment=[Node(0,0)]*(4*l)

def build(index,s,e):
    if s==e:
        segment[index]=Node(arr[s],0)
    else:
        mid=(s+e)//2
        build(index*2,s,mid)
        build(index*2+1,mid+1,e)
        segment[index]=Node(segment[index*2].sum+segment[index*2+1].sum,0)

def getxor(index,s,e,l,r,val):
  propagate(index,s,e)
  if s>r or e<l:
    return
  if l<=s and e<=r:
    segment[index].xor=val
    propagate(index,s,e)
  else:
    mid=(s+e)//2
    getxor(index*2,s,mid,l,r,val)
    getxor(index*2+1,mid+1,e,l,r,val)
    segment[index].sum=segment[index*2].sum+segment[index*2+1].sum

def propagate(index,s,e):
  segment[index].sum^=segment[index].xor
  if s!=e:
    segment[index*2].xor^=segment[index].xor
    segment[index*2+1].xor^=segment[index].xor
  segment[index].xor=0

def get_sum(index,s,e,l,r):
  # print((index,s,e,l,r))
  propagate(index,s,e)
  if s>r or e<l:
    return 0
  if l<=s and e<=r:
    return segment[index].sum
  else:
    mid=(s+e)//2
    left=get_sum(index*2,s,mid,l,r)
    right=get_sum(index*2+1,mid+1,e,l,r)
    segment[index].sum=segment[index*2].sum+segment[index*2+1].sum
    return left+right

build(1,0,l-1)
t=int(input())

for i in range(t):
  q=list(map(int,input().split(' ')))
  if q[0]==1:
    print(get_sum(1,0,l-1,q[1]-1,q[2]-1))
  else:
    getxor(1,0,l-1,q[1]-1,q[2]-1,q[3])
    for i in range(l):
      get_sum(1,0,l-1,i,i)
    # for i in range(2*l+1):
    #   print(segment[i].sum,"->",segment[i].xor,end=',  ')
    # print()


