#include <bits/stdc++.h>
#define Nmax 100005
using namespace std;
ifstream fin ( "aib.in" );
ofstream fout ( "aib.out" );
typedef long long int LL;

void Read ( );
void Add ( int i, LL val );
LL Querry ( int i, int j );
int Caut ( LL sum );

LL aib[Nmax];

int n, m;

int main ( )
{
    Read ( );
}

void Add ( int i, LL val )
{
    while ( i <= n )
    {
        aib[i] += val;

        i += (i&(-i));
    }

    return ;
}

LL Querry ( int i, int j)
{
    LL sum1, sum2;

    sum1 = sum2 = 0;

    while ( j > 0 )
    {
        sum2 += aib[j];

        j -= ( j & (-j) );
    }

    i--;

    while ( i > 0 )
    {
        sum1 += aib[i];
        i-= ( i & (-i) );
    }

    return sum2-sum1;
}

int Caut ( LL sum )
{
    int lim = log2(n);
    int st = -1, dr = lim+1, mij, i;

    while ( dr-st > 1 )
    {
        mij = (st + dr) / 2;

        i = 1 << mij;

        if ( aib[i] <= sum )
            st = mij;

        else
            dr = mij;
    }

    if ( aib[(1<<st)] == sum )
        return (1<<st);

    st = ( 1 << st )+1;
    dr = ( 1 << dr );

    LL S = aib[st-1];
    int var, lastSt;

    while ( dr-st > 1 )
    {
        if ( aib[st] + S == sum )
            return st;

        if ( aib[st] + S < sum )
        {
            lastSt = st;
            var = st + (st&(-st));
            if ( var >= dr )
            {
                S+=aib[st];
                st++;
            }
            else
                st = var;
        }

        else
        {
            dr = st;
            st = lastSt+1;
        }
    }

    if ( S+aib[st] == sum )
        return st;
    return -1;
}

void Read ( )
{
    LL a, b, task;

    fin >> n >> m;

    for ( int i = 1; i <= n; i++ )
    {
        fin >> a;
        Add ( i, a );
    }

    for ( int i = 1; i <= m; i++ )
    {
        fin >> task >> a;

        if ( task == 0 )
        {
            fin >> b;
            Add ( a, b );
        }

        else if ( task == 1 )
        {
            fin >> b;
            fout << Querry ( a, b ) << '\n';
        }

        else
            fout << Caut ( a ) << '\n';
    }
}