#include <iostream>
#include<fstream>
#include<thread>
using namespace std;
ifstream in("aib.in");
ofstream out("aib.out");


int nodes[1000000];
int elem[100000];
int n,m;

void read()
{
    in>>m>>n;
    for(int i=0; i<m; i++)
        in>>elem[i];
}

void asgn(int l,int r,int index)
{
    if(l==r)
    {
        nodes[index]=elem[l];
    }
    else
    {
        int middle=(l+r)/2;
        asgn(l,middle,index<<1);
        asgn(middle+1,r,(index<<1)+1);
        nodes[index]=nodes[index<<1]+nodes[(index<<1)+1];
    }
}

int interv(int l,int r,int desired1,int desired2,int index)
{
    int middle=(l+r)/2;
    int to_return=0;
    if(l>=desired1 && r<=desired2)
        return nodes[index];




    if(desired1<=middle)
    {
        to_return+=interv(l,middle,desired1,desired2,index<<1);
    }
    if(desired2>middle)
    {
        to_return+=interv(middle+1,r,desired1,desired2,(index<<1)+1);
    }
    return to_return;

}
void add(int l,int r,int desired,int value,int index)
{
    int middle=(l+r)/2;
    if(l<=desired && r>=desired)
    {
        nodes[index]+=value;
    }
    if(l>=r)
        return;
    if(desired<=middle)
    {
        add(l,middle,desired,value,index<<1);
    }
    else
    {
        add(middle+1,r,desired,value,(index<<1)+1);
    }

}
void add_to(int index,int value)
{
    add(0,m-1,index,value,1);


}
int get_sum_interval(int left,int right)
{

    return interv(0,m-1,left,right,1);
}


void create_tree()
{
    asgn(0,m-1,1);
}

int min_k(int sum)
{
    int l=0,r=m-1;
    while(l<=r)
    {
        int middle=(l+r)/2;
        int here=get_sum_interval(0,middle);
        if(sum<here)
        {
            r=middle-1;
        }
        else if(sum>here)
        {
            l=middle+1;
        }
        else
            return middle;
    }
    return -1;


}

void solve()
{
    int a,b,c;
    for(int i=0; i<n; i++)
    {
        in>>a;
        switch(a)
        {
        case 0:
            in>>b>>c;
            add_to(b-1,c);
            break;
        case 1:
            in>>b>>c;
            out<<get_sum_interval(b-1,c-1)<<'\n';
            break;
        case 2:
            in>>c;
            int to_output=min_k(c);
            if(to_output!=-1)
                to_output++;
            out<<to_output<<'\n';
            break;

        }
    }



}


int main()
{
    read();
    create_tree();
    solve();
    std::thread t(create_tree);

    return 0;
}