Kuriyama Mirai has killed many monsters and got many (namely n) stones. She numbers the stones from 1 to n. The cost of the i-th stone is vi. Kuriyama Mirai wants to know something about these stones so she will ask you two kinds of questions:

1. She will tell you two numbers, l and r (1 ≤ l ≤ r ≤ n), and you should tell her .
2. Let ui be the cost of the i-th cheapest stone (the cost that will be on the i-th place if we arrange all the stone costs in non-decreasing order). This time she will tell you two numbers, l and r (1 ≤ l ≤ r ≤ n), and you should tell her .

For every question you should give the correct answer, or Kuriyama Mirai will say “fuyukai desu” and then become unhappy.

Input

The first line contains an integer n (1 ≤ n ≤ 105). The second line contains n integers: v1, v2, …, vn (1 ≤ vi ≤ 109) — costs of the stones.

The third line contains an integer m (1 ≤ m ≤ 105) — the number of Kuriyama Mirai’s questions. Then follow m lines, each line contains three integers type, l and r (1 ≤ l ≤ r ≤ n; 1 ≤ type ≤ 2), describing a question. If type equal to 1, then you should output the answer for the first question, else you should output the answer for the second one.

Output

Print m lines. Each line must contain an integer — the answer to Kuriyama Mirai’s question. Print the answers to the questions in the order of input.

Sample test(s) input

6
6 4 2 7 2 7
3
2 3 6
1 3 4
1 1 6

output

24
9
28

input

4
5 5 2 3
10
1 2 4
2 1 4
1 1 1
2 1 4
2 1 2
1 1 1
1 3 3
1 1 3
1 4 4
1 2 2

output

10
15
5
15
5
5
2
12
3
5

Note

Please note that the answers to the questions may overflow 32-bit integer type.

#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
#define ll 100000
#define lson 2*i
#define rson 2*i+1
#define lc l,mid,2*i
#define rc mid+1,r,2*i+1
#define LL __int64

LL sum,n,maxn;

LL s[ll],s1[ll];

struct node
{
    LL l,r,n;
    LL sum;
} a[2][ll<<2];

void init(LL l,LL r,LL i,LL tr)
{
    a[tr][i].l = l;
    a[tr][i].r = r;
    a[tr][i].n = 0;
    a[tr][i].sum = 0;
    if(l!=r)
    {
        LL mid = (l+r)/2;
        init(lc,tr);
        init(rc,tr);
    }
}

void insert(LL i,LL x,LL m,LL tr)
{
    if(x>=a[tr][i].l && x<=a[tr][i].r)
    {
        a[tr][i].n=m;
        a[tr][i].sum=m;
    }
    if(a[tr][i].l == a[tr][i].r)
        return ;
    LL mid = (a[tr][i].l+a[tr][i].r)/2;
    if(x>mid)
        insert(2*i+1,x,m,tr);
    else
        insert(2*i,x,m,tr);
    a[tr][i].sum = a[tr][2*i].sum+a[tr][2*i+1].sum;
    a[tr][i].n = max(a[tr][2*i].n,a[tr][2*i+1].n);
}


LL find_sum(LL x,LL y,LL i,LL tr)
{
    if(a[tr][i].l == x && a[tr][i].r == y)
        return a[tr][i].sum;
    LL mid = (a[tr][i].l+a[tr][i].r)/2;
    if(x>mid)
        return find_sum(x,y,2*i+1,tr);
    else if(y<=mid)
        return find_sum(x,y,2*i,tr);
    else
        return find_sum(x,mid,2*i,tr)+find_sum(mid+1,y,2*i+1,tr);
}

int main()
{
    LL n,m,i,j,b,x,y,cas;
    scanf("%I64d",&n);
    init(1,n,1,0);
    init(1,n,1,1);
    for(i = 1; i<=n; i++)
    {
        scanf("%I64d",&s[i]);
        insert(1,i,s[i],0);
    }
    sort(s+1,s+n+1);
    for(i = 1; i<=n; i++)
    {
        insert(1,i,s[i],1);
    }
    scanf("%I64d",&m);
    while(m--)
    {
        scanf("%I64d%I64d%I64d",&cas,&x,&y);
        printf("%I64d\n",find_sum(x,y,1,cas-1));

    }

    return 0;
}