#include <cstdio>

#define BUFFER_SIZE 1 << 18

char inBuffer[BUFFER_SIZE];

int p = BUFFER_SIZE;

__attribute__((always_inline)) char get_char()
{
    if(p == BUFFER_SIZE)
    {
        fread(inBuffer, 1, BUFFER_SIZE, stdin);

        p = 0;
    }

    return inBuffer[p++];
}

__attribute__((always_inline)) int get_int()
{
    char c = get_char(); int number = 0;

    for(; c < 48 || c > 57; c = get_char());

    for(; c > 47 && c < 58; c = get_char())

        number = number * 10 + c - '0';

    return number;
}

char outBuffer[1650000]; int q = -1;

__attribute__((always_inline)) void put_int(int x)
{
    if(x == -1)
    {
        outBuffer[++q] = 45;

        outBuffer[++q] = 49;

        outBuffer[++q] = 10;

        return;
    }

    int digits = x > 999999999 ? 11 :
                 x > 99999999  ? 10 :
                 x > 9999999   ? 9  :
                 x > 999999    ? 8  :
                 x > 99999     ? 7  :
                 x > 9999      ? 6  :
                 x > 999       ? 5  :
                 x > 99        ? 4  :
                 x > 9         ? 3  : 2;

    for(int i = digits; --i; x /= 10)
    {
        outBuffer[q + i] = x % 10 + 48;
    }

    outBuffer[q = q + digits] = 10;
}

__attribute__((always_inline)) void Update(int BIT[], int length, int position, int value)
{
    for(int index = position; index <= length; index += index & -index)
    {
        BIT[index] += value;
    }
}

__attribute__((always_inline)) int Querry(int BIT[], int position)
{
    int sum = 0;

    for(int index = position; index; index -= index & -index)
    {
        sum += BIT[index];
    }

    return sum;
}

int main(){

    freopen("aib.in", "r", stdin);
    freopen("aib.out", "w", stdout);

    int length = get_int(), operations = get_int() + 1, x, y, BIT[100001];

    for(int i = 1; i <= length; ++i)
    {
        Update(BIT, length, i, get_int());
    }

    while(--operations)
    {
        switch(get_int())
        {
            case 0: x = get_int();
                    y = get_int();
                    Update(BIT, length, x, y);
                    break;

            case 1: x = get_int();
                    y = get_int();
                    put_int(Querry(BIT, y) - Querry(BIT, x - 1));
                    break;

            case 2: x = get_int();

                    int i, step, found = -1;

                    for(step = 1; step <= length; step <<= 1);

                    for(i = 0; step; step >>= 1)
                    {
                         if(i + step <= length && x >= BIT[i + step])
                         {
                            i += step;

                            x -= BIT[i];

                            if(!x)
                            {
                                found = i;

                                break;
                            }
                         }
                    }

                    put_int(found);
        }
    }

    fwrite(outBuffer, 1, q, stdout);

    return 0;
}