#include <set>
#include <map>
#include <stack>
#include <cmath>
#include <queue>
#include <string>
#include <limits>
#include <vector>
#include <bitset>
#include <limits>
#include <utility>
#include <fstream>
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>

#define MOD 10001 // daca e nevoie de mod
#define oo (1 << 30)
#define ooLL (1LL<<60)
#define lsb(x) (x&(-x)) // least significat bit of
#define eps 0.00001

typedef long long ll;
typedef long double ld;


class BinaryIndexTree {
public:
	BinaryIndexTree(ll size = 0);
	~BinaryIndexTree();
	bool inline add(ll index, ll value);
	bool inline get(ll index, ll& sum);
	ll inline search(ll sum);
private:
	bool inline check_limits(ll low, ll high);
	ll *v;
	ll size;
};

BinaryIndexTree::BinaryIndexTree(ll size)
{
	this->size = size + 1;
	v = new(std::nothrow) ll[100001];
}

BinaryIndexTree::~BinaryIndexTree()
{
	size = 0;
	delete [] v;
	v = NULL;
}

bool BinaryIndexTree::add(ll index, ll value)
{
	bool r = check_limits(index, size - 1);

	if(!r)
		return r;

	while(index <= size) {
		v[index] += value;
		index += lsb(index);
	}

	return true;
}

bool BinaryIndexTree::get(ll index, ll& sum)
{
	bool r = check_limits(index, size - 1);
	sum = 0LL;
	if(!r)
		return r;

	while(index) {
		sum += v[index];
		index -= lsb(index);
	}
	return true;
}
ll BinaryIndexTree::search(ll sum)
{
	ll step = 1 << 30;
	for (ll idx = 0; 0 != step; step >>= 1) {
		if (idx + step <= size && v[idx + step] <= sum) {
			idx += step;
			sum -= v[idx];
			if (0 == sum) {
				return idx;
			}
		}
	}
	return 1LL * (-1);
}

bool BinaryIndexTree::check_limits(ll low, ll high)
{
	if (low > high || low < 0 || high < 0 || high > size) {
		return false;
	}
	return true;
}


int main()
{
	std::ifstream cin("aib.in");
	std::ofstream cout("aib.out");

	ll N;
	ll M;
	ll temp;
	ll op;
	ll a, b;
	ll s1 = 0;
	ll s2 = 0;

	cin >> N >> M;
	BinaryIndexTree bit(N);
	for (int i = 1; i <= N; ++i) {
		cin >> temp;
		bit.add(i, temp);
	}

	for (int i = 1; i <= M; ++i) {
		cin >> op;
		if (0 == op) {
			cin >> a >> b;
			bit.add(a, b);
		} else if (1 == op) {
			cin >> a >> b;
			bit.get(a - 1, s1);
			bit.get(b, s2);
			cout << s2 - s1  << "\n";
		} else if (2 == op) {
			cin >> a;
			cout << bit.search(a) << "\n";
		}
	}


	cin.close();
	cout.close();
	return 0;
}