


from __future__ import annotations

import math







class  snake_case_     :
					def __init__(   self     :Tuple    ,__snake_case     :int   )      ->					None:
												a__    =  size
												# approximate the overall size of segment tree with given value
												a__    =  [0 for i in range(0    ,4 * size   )]
												# create array to store lazy update
												a__    =  [0 for i in range(0    ,4 * size   )]
												a__    =  [0 for i in range(0    ,4 * size   )]  # flag for lazy update
					def 				lowerCamelCase__(   self     :Tuple    ,__snake_case     :int   )      ->					int:
												return idx * 2
					def 				lowerCamelCase__(   self     :Any    ,__snake_case     :int   )      ->					int:
												return idx * 2 + 1
					def 				lowerCamelCase__(   self     :Any    ,__snake_case     :int    ,__snake_case     :int    ,__snake_case     :int    ,__snake_case     :list[int]   )      ->					None:
												if left_element == right_element:
																			a__    =  a[left_element - 1]
												else:
																			a__    =  (left_element + right_element) // 2
																			self.build(self.left(__snake_case   )    ,__snake_case    ,__snake_case    ,__snake_case   )
																			self.build(self.right(__snake_case   )    ,mid + 1    ,__snake_case    ,__snake_case   )
																			a__    =  max(
																			    self.segment_tree[self.left(__snake_case   )]    ,self.segment_tree[self.right(__snake_case   )]   )
					def 				lowerCamelCase__(   self     :Tuple    ,__snake_case     :int    ,__snake_case     :int    ,__snake_case     :int    ,__snake_case     :int    ,__snake_case     :int    ,__snake_case     :int   )      ->					bool:
												if self.flag[idx] is True:
																			a__    =  self.lazy[idx]
																			a__    =  False
																			if left_element != right_element:
																										a__    =  self.lazy[idx]
																										a__    =  self.lazy[idx]
																										a__    =  True
																										a__    =  True

												if right_element < a or left_element > b:
																			return True
												if left_element >= a and right_element <= b:
																			a__    =  val
																			if left_element != right_element:
																										a__    =  val
																										a__    =  val
																										a__    =  True
																										a__    =  True
																			return True
												a__    =  (left_element + right_element) // 2
												self.update(self.left(__snake_case   )    ,__snake_case    ,__snake_case    ,__snake_case    ,__snake_case    ,__snake_case   )
												self.update(self.right(__snake_case   )    ,mid + 1    ,__snake_case    ,__snake_case    ,__snake_case    ,__snake_case   )
												a__    =  max(
												    self.segment_tree[self.left(__snake_case   )]    ,self.segment_tree[self.right(__snake_case   )]   )
												return True
					def 				lowerCamelCase__(   self     :Dict    ,__snake_case     :int    ,__snake_case     :int    ,__snake_case     :int    ,__snake_case     :int    ,__snake_case     :int   )      ->					int | float:
												if self.flag[idx] is True:
																			a__    =  self.lazy[idx]
																			a__    =  False
																			if left_element != right_element:
																										a__    =  self.lazy[idx]
																										a__    =  self.lazy[idx]
																										a__    =  True
																										a__    =  True
												if right_element < a or left_element > b:
																			return -math.inf
												if left_element >= a and right_element <= b:
																			return self.segment_tree[idx]
												a__    =  (left_element + right_element) // 2
												a__    =  self.query(self.left(__snake_case   )    ,__snake_case    ,__snake_case    ,__snake_case    ,__snake_case   )
												a__    =  self.query(self.right(__snake_case   )    ,mid + 1    ,__snake_case    ,__snake_case    ,__snake_case   )
												return max(__snake_case    ,__snake_case   )



					def __str__(   self     :Tuple   )      ->					str:
												return str([self.query(1    ,1    ,self.size    ,__snake_case    ,__snake_case   ) for i in range(1    ,self.size + 1   )]   )


if __name__ == "__main__":
						snake_case							: List[str]      =   [1, 2, -4, 7, 3, -5, 6, 11, -20, 9, 14, 15, 5, 2, -8]
						snake_case							: Any      =   15
						snake_case							: List[str]      =   SegmentTree(size)
						segt.build(1, 1, size, A)
						print(segt.query(1, 1, size, 4, 6))
						print(segt.query(1, 1, size, 7, 11))
						print(segt.query(1, 1, size, 7, 12))
						segt.update(1, 1, size, 1, 3, 1_11)
						print(segt.query(1, 1, size, 1, 15))
						segt.update(1, 1, size, 7, 8, 2_35)
						print(segt)








from math import pi






def 							__lowercase     (				__lowerCAmelCase							:       int      ,					__lowerCAmelCase							:       int     ):
							return 2 * pi * radius * (angle / 3_6_0)


if __name__ == "__main__":
						print(arc_length(90, 10))




