/* 2003 MO P-I-3
 *
 * Petr Baudis
 * OKTAVA, gymnazium Ad Fontes Jihlava
 *
 * Abychom mohli nad polem efektivne implementovat scitani rady prvku v urcitem
 * intervalu, zrejme bude vhodne si cachovat urcite mezisoucty, scitani pak
 * bude obstavat v zasade z hledani vhodnych mezisouctu a jejich secteni.
 * Modifikace by pak obnasela obnoveni relevantnich mezisouctu.
 *
 * Neco takoveho nejvhodneji implementujeme binarnim stromem, ktery si nad
 * polem postavime. Na nejvyssi urovni bude soucet celeho pole, zatimco na
 * nejnizsi urovni budou prvky tohoto pole (za koncem pole pak nuly). Kazdy
 * z vyssich prvku pak bude obsahovat soucet svych dvou potomku:
 *
 * 1 4 3 1 1 3 1 1 3 1 4 1 1 1 0 0
 *
 *  5   4   4   2   4   5   2   0
 *
 *    9       8       9       2
 *
 *       17               11
 *
 *                28
 *
 * V pameti si budeme ukladat binarni strom, coz nam zabere O(N) mista.
 * Vytvorit tento strom nam zabere take O(N).
 *
 * Zmena hodnoty prvku bude obnaset zaroven modifikaci jednoho prvku v kazde
 * vyssi urovni stromu, pricemz techto urovni je samozrejme log N. Proto bude
 * narocnost teto operace O(log N).
 *
 * Co se tyce zjisteni souctu prvku v intervalu x..y, zacneme v danem prvku a
 * pak rekurzivne se vzdy posuneme vyse s tim, ze jako hodnotu prvku si budeme
 * pamatovat hodnotu prvku, ze ktereho jsme vysli, plus pripadne hodnotu
 * sourozence, ale pouze, pokud pro x je sourozenec vpravo a pro y je naopak
 * vlevo. V miste, kde se setkame, pak secteme hodnoty pro xovou i yovou vetev.
 * Opet na kazde urovni navstivime ne vice nez dva prvky, takze narocnost teto
 * operace bude nejvyse O(log N). */

#include <stdio.h>
#include <stdlib.h>

/* Na konci pole seznam cisel, pak vzdy polovicni uroven */
static long pole[5000]; /* 2*2000 plus kousek rezervy ;) */

int
main()
{
  long n, i, j;
  int op;

  scanf("%ld", &n);
  for (i = 1; i < n; i *= 2) /* dorovname pole */ ;
  for (j = 0; j < n; j++)
    scanf("%ld", &pole[i + j]);
  n = i;

  /* Predzpracovani */

  for (i--; i > 0; i--)
    pole[i] = pole[2 * i] + pole[2 * i + 1];

  /* Operace */

  do {
    long x, y;

    scanf("%d %ld %ld", &op, &x, &y);
    x--; /* cislujeme od nuly */
    switch (op) {
      case 1:
	j = y - pole[x + n];
	for (i = x + n; i > 0; i /= 2) pole[i] += j;
	break;
      case 2:
	y--;
	/* sude: vlevo, liche: vpravo */
	{
	  long xh, yh;

	  x += n; y += n;
	  xh = pole[x]; yh = pole[y];

	  while ((x / 2) != (y / 2)) {
	    if (!(x % 2)) xh += pole[x + 1];
	    if (y % 2) yh += pole[y - 1];
	    x /= 2; y /= 2;
	  }

	  printf("%ld\n", xh + yh);
	}
	break;
    }
  } while (op);

  return 0;
}