'''simple docstring'''




def     __snake_case			(							lowerCAmelCase							:  int      ):
 __UpperCAmelCase								=       abs(a_      )
 __UpperCAmelCase								=       0
 while n > 0:
  res += n % 10
  n //= 10
 return res



def     __snake_case			(							lowerCAmelCase							:  int      ):
 __UpperCAmelCase								=       abs(a_      )
 return n if n < 10 else n % 10 + sum_of_digits(n // 10      )



def     __snake_case			(							lowerCAmelCase							:  int      ):
 return sum(int(a_      ) for c in str(abs(a_      )      )      )



def     __snake_case			(							):
 from collections.abc import Callable
 from timeit import timeit

 def benchmark_a_function(lowerCAmelCase							:  Callable   ,	lowerCAmelCase							:  int      ) -> None:
  __UpperCAmelCase								=       F"""{func.__name__}({value})"""
  __UpperCAmelCase								=       timeit(F"""__main__.{call}"""   ,	setup='import __main__'      )
  print(F"""{call:56} = {func(a_      )} -- {timing:.4f} seconds"""      )

 for value in (26_2144, 1125_8999_0684_2624, 126_7650_6002_2822_9401_4967_0320_5376):
  for func in (sum_of_digits, sum_of_digits_recursion, sum_of_digits_compact):
   benchmark_a_function(a_   ,	a_      )
  print()


if __name__ == "__main__":
     import doctest

     doctest.testmod()
     benchmark()











'''simple docstring'''

def 				snake_case       (  a_				:			str     , a_				:			Optional[int]						)							->					Any:





      """simple docstring"""

      UpperCamelCase_					: Tuple            =				(boundary[1] - boundary[0]) / steps
      UpperCamelCase_					: Dict            =				boundary[0]
      UpperCamelCase_					: Any            =				boundary[1]
      UpperCamelCase_					: Union[str, Any]            =				make_points(a_     , a_     , a_						)
      UpperCamelCase_					: Any            =				0.0
      y += (h / 2.0) * f(a_						)
      for i in x_i:
            # print(i)
            y += h * f(a_						)
      y += (h / 2.0) * f(a_						)
      return y



def 				snake_case       (  a_				:			Tuple     , a_				:			Any     , a_				:			Tuple						)							->					Tuple:





      """simple docstring"""

      UpperCamelCase_					: Optional[int]            =				a + h
      while x < (b - h):
            yield x
            UpperCamelCase_					: List[str]            =				x + h



def 				snake_case       (  a_				:			List[str]						)							->					Tuple:  # enter your function here





      """simple docstring"""

      UpperCamelCase_					: int            =				(x - 0) * (x - 0)
      return y



def 				snake_case       (  )							->					Dict:





      """simple docstring"""

      UpperCamelCase_					: Optional[Any]            =				0.0  # Lower bound of integration
      UpperCamelCase_					: Optional[int]            =				1.0  # Upper bound of integration
      UpperCamelCase_					: Optional[Any]            =				10.0  # define number of steps or resolution
      UpperCamelCase_					: Optional[Any]            =				[a, b]  # define boundary of integration
      UpperCamelCase_					: Any            =				method_a(a_     , a_						)
      print(f"y = {y}"						)


if __name__ == "__main__":
      main()






