__snake_case						=			{
    0: '''0''',
    1: '''1''',
    2: '''2''',
    3: '''3''',
    4: '''4''',
    5: '''5''',
    6: '''6''',
    7: '''7''',
    8: '''8''',
    9: '''9''',
    10: '''a''',
    11: '''b''',
    12: '''c''',
    13: '''d''',
    14: '''e''',
    15: '''f''',
}





def      lowerCAmelCase_       ( __lowerCAmelCase  )->     Tuple:






      '''simple docstring'''





      assert type(__lowerCAmelCase  ) in (int, float) and decimal == int(__lowerCAmelCase  )
      UpperCAmelCase			:       List[Any]			     =int(__lowerCAmelCase  )
      UpperCAmelCase			:       Dict			     =""
      UpperCAmelCase			:       Any			     =False
      if decimal < 0:
            UpperCAmelCase			:       Optional[Any]			     =True
            decimal *= -1
      while decimal > 0:
            UpperCAmelCase			:       List[Any]			     =divmod(__lowerCAmelCase						,    16  )
            UpperCAmelCase			:       List[Any]			     =values[remainder] + hexadecimal
      UpperCAmelCase			:       Optional[int]			     ="0x" + hexadecimal
      if negative:
            UpperCAmelCase			:       Optional[int]			     ="-" + hexadecimal
      return hexadecimal


if __name__ == "__main__":
     import doctest

     doctest.testmod()

from collections.abc import Sequence
from queue import Queue






class 		a__						:

					def __init__(    self      :       int,_A      :       List[Any],_A      :       Optional[Any],_A      :       Optional[int],_A      :       int=None,_A      :       List[str]=None    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    start
							SCREAMING_SNAKE_CASE_  :		List[str]				      =    end
							SCREAMING_SNAKE_CASE_  :		Tuple				      =    val
							SCREAMING_SNAKE_CASE_  :		List[str]				      =    (start + end) // 2
							SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    left
							SCREAMING_SNAKE_CASE_  :		str				      =    right






					def __repr__(    self      :       Tuple    ):







							"""simple docstring"""






							return F'SegmentTreeNode(start={self.start}, end={self.end}, val={self.val})'







class 		a__						:

					def __init__(    self      :       Any,_A      :       Sequence,_A      :       str    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Optional[Any]				      =    collection
							SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    function
							if self.collection:
									SCREAMING_SNAKE_CASE_  :		List[str]				      =    self._build_tree(0,len(_A    ) - 1    )

					def 				__UpperCamelCase   (    self      :       int,_A      :       Any,_A      :       List[Any]    ):







							"""simple docstring"""






							self._update_tree(self.root,_A,_A    )

					def 				__UpperCamelCase   (    self      :       str,_A      :       Any,_A      :       List[Any]    ):







							"""simple docstring"""






							return self._query_range(self.root,_A,_A    )

					def 				__UpperCamelCase   (    self      :       Any,_A      :       Optional[int],_A      :       int    ):







							"""simple docstring"""






							if start == end:
									return SegmentTreeNode(_A,_A,self.collection[start]    )
							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    (start + end) // 2
							SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    self._build_tree(_A,_A    )
							SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    self._build_tree(mid + 1,_A    )
							return SegmentTreeNode(_A,_A,self.fn(left.val,right.val    ),_A,_A    )

					def 				__UpperCamelCase   (    self      :       int,_A      :       int,_A      :       Tuple,_A      :       Dict    ):







							"""simple docstring"""






							if node.start == i and node.end == i:
									SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    val
									return
							if i <= node.mid:
									self._update_tree(node.left,_A,_A    )
							else:
									self._update_tree(node.right,_A,_A    )
							SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    self.fn(node.left.val,node.right.val    )

					def 				__UpperCamelCase   (    self      :       str,_A      :       List[str],_A      :       Optional[int],_A      :       Optional[Any]    ):







							"""simple docstring"""






							if node.start == i and node.end == j:
									return node.val

							if i <= node.mid:
									if j <= node.mid:
											# range in left child tree
											return self._query_range(node.left,_A,_A    )
									else:
											# range in left child tree and right child tree
											return self.fn(
											    self._query_range(node.left,_A,node.mid    ),self._query_range(node.right,node.mid + 1,_A    ),)
							else:
									# range in right child tree
									return self._query_range(node.right,_A,_A    )






					def 				__UpperCamelCase   (    self      :       Optional[Any]    ):







							"""simple docstring"""






							if self.root is not None:
									SCREAMING_SNAKE_CASE_  :		int				      =    Queue()
									queue.put(self.root    )
									while not queue.empty():
											SCREAMING_SNAKE_CASE_  :		Tuple				      =    queue.get()
											yield node

											if node.left is not None:
													queue.put(node.left    )

											if node.right is not None:
													queue.put(node.right    )


if __name__ == "__main__":
		import operator

		for fn in [operator.add, max, min]:
				print('''*''' * 50)
				__lowerCamelCase					:	int       =  SegmentTree([2, 1, 5, 3, 4], fn)
				for node in arr.traverse():
						print(node)
				print()

				arr.update(1, 5)
				for node in arr.traverse():
						print(node)
				print()

				print(arr.query_range(3, 4))  # 7
				print(arr.query_range(2, 2))  # 5
				print(arr.query_range(1, 3))  # 13
				print()
