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;
use std::clone::Clone;

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 BIT {
    n: usize, 
    data: Vec<i64>,
}

impl BIT {
    fn new(n: usize) -> BIT {
        let mut vec = vec![0; n+1];
        BIT {
            n: n, 
            data: vec
        }
    }

    fn add(&mut self, i: usize, x: i64) {
        let mut i: i32 = i as i32;
        while i <= (self.n as i32) {
            self.data[i as usize] += x;
            i = i + (i & -i);
        }
    }

    // [1, i] での和
    fn sum(&mut self, i: usize) -> i64 {
        let mut i: i32 = i as i32;
        let mut ret: i64 = 0;
        while i > 0 {
            ret += self.data[i as usize];
            i = i - (i & -i);
        }
        return ret
    }
}

fn main() {
    let n: usize = read();
    let q: usize = read();

    let mut tree = BIT::new(n);

    for _ in 0..q {
        let com: u8 = read();
        let x: usize = read();
        let y: i64 = read();
        if com == 0 {
            tree.add(x, y);
        } else {
            println!("{}", tree.sum(y as usize) - tree.sum(x-1));
        }
    }
}