Problem:
Range Sum Query

Write a program which manipulates a sequence A = {a1, a2, . . . , an} with the following operations:

add(i, x): add x to ai.

getSum(s, t): print the sum of as, as+1,...,at.

Note that the initial values of ai (i = 1, 2, . . . , n) are 0.

Input

n q
com1 x1 y1
com2 x2 y2
...
comq xq yq

In the first line, n (the number of elements in A) and q (the number of queries) are given. Then, q queries are given where com represents the type of queries. '0' denotes add(xi, yi) and '1' denotes getSum(xi, yi).

Output

For each getSum operation, print the sum in a line.

Constraints

1 ≤ n ≤ 100000

1 ≤ q ≤ 100000

If comi is 0, then 1 ≤ xi ≤ n, 0 ≤ yi ≤ 1000.

If comi is 1, then 1 ≤ xi ≤ n, 1 ≤ yi ≤ n.

Sample Input 1

3 5
0 1 1
0 2 2
0 3 3
1 1 2
1 2 2

Sample Output 1

3
2

Solution in C# (judge verdict: Accepted)

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net.NetworkInformation;
using System.Text;
using System.Text.RegularExpressions;
using static System.Math;

namespace CSharpSpiral {
	class Program {
		static void Main(string[] args) {
			var sw = new StreamWriter(Console.OpenStandardOutput()) {
				AutoFlush=
#if DEBUG
			true
#else
			false
#endif
			};
			Console.SetOut(sw);
			new Program().Solve(new ConsoleInput(
#if DEBUG
			new StreamReader("../../../inputData.txt")
#else
			Console.In
#endif
			, ' '));
			Console.Out.Flush();
		}
		public void Solve(ConsoleInput cin) {
			var N = cin.ReadInt;
			var Q = cin.ReadInt;
			Func<int, int, int> ADD = (i, j) => i+j;
			var T = new SegmentTree<int>((int)Log(N,2)+2, ADD, 0);
			for(int j = 0; j<Q; j++) {
				var query = cin.ReadIntArray(3);
				switch(query[0]) {
					case 0:
						T.ImmediateOperate(query[1]-1, query[2], ADD);
						break;
					default:
						Console.WriteLine(T.GetValue(query[1]-1, query[2]));
						break;
				}
			}
		}
	}
	static class ExtendClass {
		public static void Swap<T>(this T[] A, int x, int y) {
			var tmp = A[x];
			A[x]=A[y];
			A[y]=tmp;
		}
		public static string Join<T>(this IEnumerable<T> X, string separator = " ") => string.Join(separator, X);
		public static IEnumerable<int> Indices<T>(this T[] X) => Enumerable.Range(0, X.Length);
		public static IEnumerable<int> Indices<T>(this T[,] X, int dim)
			=> Enumerable.Range(0, X.GetLength(dim));
		public static string Join<T>(this T[,] X, string separatorD2 = ",", string separatorD1 = "\n")
			=> X.Indices(0).Select(
				i => X.Indices(1).Select(j => X[i, j]).Join(separatorD2)
			).Join(separatorD1);
	}
	class ConsoleInput {
		private readonly TextReader _stream;
		private readonly char _separator = ' ';
		private readonly Queue<string> inputStream;
		public ConsoleInput(TextReader stream, char separator = ' ') {
			this._separator=separator;
			this._stream=stream;
			inputStream=new Queue<string>();
		}
		public string Read {
			get {
				if(inputStream.Count!=0) return inputStream.Dequeue();
				string[] tmp = _stream.ReadLine().Split(_separator);
				for(int i = 0; i<tmp.Length; ++i)
					inputStream.Enqueue(tmp[i]);
				return inputStream.Dequeue();
			}
		}
		public string ReadLine { get { return _stream.ReadLine(); } }
		public int ReadInt { get { return int.Parse(Read); } }
		public long ReadLong { get { return long.Parse(Read); } }
		public double ReadDouble { get { return double.Parse(Read); } }
		public string[] ReadStrArray(long N) {
			var ret = new string[N];
			for(long i = 0; i<N; ++i)
				ret[i]=Read;
			return ret;
		}
		public int[] ReadIntArray(long N) { var ret = new int[N]; for(long i = 0; i<N; ++i) ret[i]=ReadInt; return ret; }
		public long[] ReadLongArray(long N) { var ret = new long[N]; for(long i = 0; i<N; ++i) ret[i]=ReadLong; return ret; }
		public double[] ReadDoubleArray(long N) { var ret = new double[N]; for(long i = 0; i<N; ++i) ret[i]=ReadDouble; return ret; }
		public bool isEOF {
			get { return _stream.Peek()==-1; }
		}
	}
	class SegmentTree<T> {
		public readonly int rank;
		public T[] Nodes { get; }
		public Func<T, T, T> OPER { get; }
		public T unit { get; }
		private int width { get { return 1<<(rank-1); } }
		private T raise(int c) {
			return (c&1)==0
			? OPER(Nodes[c-1], Nodes[(c-1)+1]) //$c is even
			: OPER(Nodes[(c-1)-1], Nodes[c-1]); //odd
		}
		private int leafIndex(int x) => (1<<(rank-1))+(x-1);
		public SegmentTree(int _rank, Func<T, T, T> _OPER, T _unit) {
			rank=_rank;
			Nodes=Enumerable.Repeat(_unit, (1<<_rank)-1).ToArray();
			OPER=_OPER;
			unit=_unit;
		}
		public void ImmediateUpdate(int x, T value) {
			var r = rank-1;
			var jc = (1<<r)+x;
			Nodes[jc-1]=value;
			for(r--; r>=0; r--) {
				var parentIndex = (jc>>1)-1;
				var oldValue = Nodes[parentIndex];
				Nodes[parentIndex]=raise(jc);
				if(oldValue.Equals(Nodes[parentIndex])) break;
				jc>>=1;
			}
		}
		public void ImmediateOperate<S>(int x, S value, Func<S, T, T> OP) {
			ImmediateUpdate(x, OP(value, Nodes[leafIndex(x)]));
		}
		public T GetValue(int start, int end) => GV(start, end, 1, 0, width);
		private T GV(int start, int end, int count, int focusStart, int focusEnd) {
			if(focusEnd<=start||end<=focusStart) return unit;
			if(start<=focusStart&&focusEnd<=end) return Nodes[count-1];
			var mid = focusStart+(focusEnd-focusStart)/2;
			return OPER(
				GV(start, end, count*2, focusStart, mid),
				GV(start, end, count*2+1, mid, focusEnd)
			);
		}
		public IEnumerable<T> GetLayer(int c) => Nodes.Skip((1<<(c-1))-1).Take(1<<(c-1));
		public IEnumerable<T> GetLeaves() => Nodes.Skip((1<<(rank-1))-1).Take(1<<(rank-1));

	}
}