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 Rust (judge verdict: Accepted)

use std::io::*;
use std::str::FromStr;

fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

struct SegmentTree{
	seg: Vec<i64>,
	sz: usize,
}
	
impl SegmentTree {
	fn new(n: usize) -> SegmentTree {
		let mut sz: usize = 1;
		while sz < n { sz *= 2; }
		
		SegmentTree {
			seg: vec![0; 2 * sz],
			sz : sz,
		}
	}
	
	fn add(&mut self, mut k: usize, x: i64) {
		k += self.sz - 1;
		self.seg[k] += x;
		
		while k > 0 {
			k = (k - 1) / 2;
			self.seg[k] = self.seg[2 * k + 1] + self.seg[2 * k + 2];
		}
	}
	
	fn _get(&self, a: usize, b: usize, k: usize, l: usize, r: usize) -> i64 {
		if b <= l || r <= a { return 0; }
		if a <= l && r <= b { return self.seg[k]; }
		
		SegmentTree::_get(self, a, b, 2 * k + 1, l, (l + r) / 2) + SegmentTree::_get(self, a, b, 2 * k + 2, (l + r) / 2, r)
	}
	
	fn get(&self, a: usize, b: usize) -> i64 {
		SegmentTree::_get(self, a, b, 0, 0, self.sz)
	}
}

fn main() {
	let (n, q): (usize, usize) = (read(), read());
	let mut seg: SegmentTree = SegmentTree::new(n);
	
	for i in 0 .. q {
		let (mut a, mut b, c): (usize, usize, usize) = (read(), read(), read());
		
		if a == 0 {
			SegmentTree::add(&mut seg, b - 1, c as i64);
		} else if a == 1 {
			let s: i64 = SegmentTree::get(&seg, b - 1, c);
			
			println!("{}", s);
		}
	}
}