output_description: For each getSum operation, print the sum in a line.
input_description: 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).
attempt: #!/usr/bin/env python
  # -*- coding: utf-8 -*-
  
  """
  input:
  3 5
  0 1 1
  0 2 2
  0 3 3
  1 1 2
  1 2 2
  
  output:
  3
  2
  """
  
  import sys
  
  
  class BinaryIndexedTree(object):
      __slots__ = ("length", "dat")
  
      def __init__(self, n):
          """
          Init a BIT with update and find for range sum queries.
          """
          self.length = int(n)
          self.dat = [0] * (self.length + 1)
  
      # sum(A[1] ... A[i])
      def __init_sum(self, i):
          _sum = 0
          while i > 0:
              _sum += self.dat[i]
              i -= i & (-i)
          return _sum
  
      def get_sum(self, s, t):
          return self.__init_sum(t) - self.__init_sum(s - 1)
  
      # A[i] += x
      def get_add(self, i, x):
          while i <= self.length:
              self.dat[i] += x
              i += i & (-i)
          return None
  
  
  def action(cmd_list):
      case = BinaryIndexedTree(n_num)
  
      for query in cmd_list:
          cmd, ele_1, ele_2 = map(int, query)
          if cmd == 0:
              case.get_add(ele_1, ele_2)
          elif cmd == 1:
              res = case.get_sum(ele_1, ele_2)
              print(res)
  
      return case
  
  
  if __name__ == "__main__":
      _input = sys.stdin.readlines()
      n_num, q_num = map(int, _input[0].split())
      q_list = map(lambda x: x.split(), _input[1:])
  
      ans = action(q_list)
  
problem_description: 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.
samples: [{"input": "3 5\n    0 1 1\n    0 2 2\n    0 3 3\n    1 1 2\n    1 2 2", "output": "3\n    2"}]