





def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase )			->     int:
    lowerCamelCase__    :      List[Any]					 =		abs(_UpperCAmelCase )
    lowerCamelCase__    :      Union[str, Any]					 =		0
    while n > 0:
        res += n % 10
        n //= 10
    return res


def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase )			->     int:
    lowerCamelCase__    :      Any					 =		abs(_UpperCAmelCase )
    return n if n < 10 else n % 10 + sum_of_digits(n // 10 )


def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase )			->     int:
    return sum(int(_UpperCAmelCase ) for c in str(abs(_UpperCAmelCase ) ) )


def        SCREAMING_SNAKE_CASE      (       )			->     None:
    from collections.abc import Callable
    from timeit import timeit

    def benchmark_a_function(_UpperCAmelCase						,	_UpperCAmelCase ) -> None:
        lowerCamelCase__    :      Dict					 =		F"""{func.__name__}({value})"""
        lowerCamelCase__    :      Union[str, Any]					 =		timeit(F"""__main__.{call}"""						,	setup='import __main__' )
        print(F"""{call:56} = {func(_UpperCAmelCase )} -- {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(_UpperCAmelCase						,	_UpperCAmelCase )
        print()


if __name__ == "__main__":
    import doctest

    doctest.testmod()
    benchmark()












from __future__ import annotations

import math


def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase )			->     bool:

    if 1 < number < 4:
        # 2 and 3 are primes
        return True
    elif number < 2 or number % 2 == 0 or number % 3 == 0:
        # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
        return False

    # All primes number are in format of 6k +/- 1
    for i in range(5						,	int(math.sqrt(_UpperCAmelCase ) + 1 )						,	6 ):
        if number % i == 0 or number % (i + 2) == 0:
            return False
    return True


_UpperCAmelCase				:       Any	   =				[num for num in range(3, 10_00_01, 2) if not is_prime(num)]


def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase )			->     list[int]:
    if not isinstance(_UpperCAmelCase						,	_UpperCAmelCase ):
        raise ValueError('n must be an integer' )
    if n <= 0:
        raise ValueError('n must be >= 0' )

    lowerCamelCase__    :      int					 =		[]
    for num in range(len(_UpperCAmelCase ) ):
        lowerCamelCase__    :      Union[str, Any]					 =		0
        while 2 * i * i <= odd_composites[num]:
            lowerCamelCase__    :      Dict					 =		odd_composites[num] - 2 * i * i
            if is_prime(_UpperCAmelCase ):
                break
            i += 1
        else:
            list_nums.append(odd_composites[num] )
            if len(_UpperCAmelCase ) == n:
                return list_nums

    return []


def        SCREAMING_SNAKE_CASE      (       )			->     int:
    return compute_nums(1 )[0]


if __name__ == "__main__":
    print(F"""{solution() = }""")





