#include <iostream>
using namespace std;
struct intrv
{
	int l, r;
};

struct nod
{
	int sum;
	nod *left, *right;
};

struct IdxTree
{
private:
	nod *head;

public:
	bool init = false;
	IdxTree()
	{
		head = new nod;
		init = 1;
	}

	void Add(int val)
	{

	}

};

void Add(int*, int, int, nod*);
void Update(nod*, int, int, int, int);
int Find(nod*, int, int, int, int);

int main()
{
	int N, M, rVal, rVal2;
	int *partSum;
	freopen("datorii.in", "r", stdin);
	freopen("datorii.out", "w", stdout);
	cin >> N >> M;

	partSum = new int[N];
	cin >> partSum[0];
	for (int i = 1; i < N; i++)
	{
		cin >> partSum[i];
		partSum[i] += partSum[i - 1];
	}

	nod *idxTree = new nod;
	idxTree->left = idxTree->right = NULL;
	Add(partSum, 0, N - 1, idxTree);
	delete partSum;
	/*Update(idxTree, 0, N - 1, 2, 4);
	cout << Find(idxTree, 0, N - 1, 2, 4);*/

	for (int i = 0; i < M; i++)
	{
		cin >> rVal;
		if (rVal == 0)
		{
			cin >> rVal >> rVal2;
			Update(idxTree, 0, N - 1, rVal - 1, rVal2);
		}
		else if (rVal == 1)
		{
			cin >> rVal >> rVal2;
			cout << Find(idxTree, 0, N - 1, rVal - 1, rVal2 - 1) << endl;
		}
	}
	//getchar();
	//getchar();
	return 0;
}

void Add(int *pS, int s, int n, nod* iT)
{
	if (s - 1 < 0)
		iT->sum = pS[n];
	else
		iT->sum = pS[n] - pS[s - 1];

	if (n - s == 0)
		return;

	if (!iT->left)
	{
		iT->left = new nod;
		iT->left->left = iT->left->right = NULL;
	}
	Add(pS, s, (n - s) / 2 + s, iT->left);
	if (!iT->right)
	{
		iT->right = new nod;
		iT->right->left = iT->right->right = NULL;
	}
	Add(pS, (n - s) / 2 + s + 1, n, iT->right);
}

void Update(nod *iT, int s, int n, int p, int val)
{
	if (s == p && p == n)
	{
		iT->sum -= val;
		return;
	}
	if (s <= p && p <= (n - s) / 2 + s)
	{
		Update(iT->left, s, (n - s) / 2 + s, p, val);
	}
	else if (p > (n - s) / 2 + s && p <= n)
	{
		Update(iT->right, (n - s) / 2 + s + 1, n, p, val);
	}
	iT->sum = iT->left->sum + iT->right->sum;
}

int Find(nod *iT, int s, int n, int ps, int pn)
{
	int res = 0;
	if (s == ps && n == pn)
		return iT->sum;
	if (s <= ps && ps <= (n - s) / 2 + s)
	{
		res += Find(iT->left,
			s,
			(n - s) / 2 + s,
			ps,
			pn < (n - s) / 2 + s ? pn : (n - s) / 2 + s);
	}
	if (pn >(n - s) / 2 + s)
	{
		res += Find(iT->right,
			(n - s) / 2 + s + 1,
			n,
			ps > (n - s) / 2 + s ? ps : (n - s) / 2 + s + 1,
			pn);
	}
	return res;
}