



from operator import delitem, getitem, setitem

import pytest

from data_structures.hashing.hash_map import HashMap


def 		_UpperCAmelCase				(      snake_case			):





					"""simple docstring"""

					return getitem, k


def 		_UpperCAmelCase				(      snake_case	,						snake_case			):





					"""simple docstring"""

					return setitem, k, v


def 		_UpperCAmelCase				(      snake_case			):





					"""simple docstring"""

					return delitem, k


def 		_UpperCAmelCase				(      snake_case	,						snake_case	,						*snake_case			):





					"""simple docstring"""

					try:
										return fun(snake_case	,						*snake_case			), None
					except Exception as e:
										return None, e


A__	      =       (
    _set("""key_a""", """val_a"""),
    _set("""key_b""", """val_b"""),
)

A__	      =       [
    _set("""key_a""", """val_a"""),
    _set("""key_a""", """val_b"""),
]

A__	      =       [
    _set("""key_a""", """val_a"""),
    _set("""key_b""", """val_b"""),
    _del("""key_a"""),
    _del("""key_b"""),
    _set("""key_a""", """val_a"""),
    _del("""key_a"""),
]

A__	      =       [
    _get("""key_a"""),
    _del("""key_a"""),
    _set("""key_a""", """val_a"""),
    _del("""key_a"""),
    _del("""key_a"""),
    _get("""key_a"""),
]

A__	      =       [
    *[_set(x, x) for x in range(5)],  # guaranteed upsize
]

A__	      =       [
    *[_set(x, x) for x in range(5)],  # guaranteed upsize
    *[_del(x) for x in range(5)],
    _set("""key_a""", """val_b"""),
]


@pytest.mark.parametrize(
    """operations"""	,						(
        pytest.param(_add_items	,						id="""add items"""			),
        pytest.param(_overwrite_items	,						id="""overwrite items"""			),
        pytest.param(_delete_items	,						id="""delete items"""			),
        pytest.param(_access_absent_items	,						id="""access absent items"""			),
        pytest.param(_add_with_resize_up	,						id="""add with resize up"""			),
        pytest.param(_add_with_resize_down	,						id="""add with resize down"""			),
    )	,						)
def 		_UpperCAmelCase				(      snake_case			):





					"""simple docstring"""

					_lowerCAmelCase						=    HashMap(initial_block_size=4			)
					_lowerCAmelCase						=    {}
					for _, (fun, *args) in enumerate(snake_case			):
										_lowerCAmelCase	,	_lowerCAmelCase						=    _run_operation(snake_case	,						snake_case	,						*snake_case			)
										_lowerCAmelCase	,	_lowerCAmelCase						=    _run_operation(snake_case	,						snake_case	,						*snake_case			)
										assert my_res == py_res
										assert str(snake_case			) == str(snake_case			)
										assert set(snake_case			) == set(snake_case			)
										assert len(snake_case			) == len(snake_case			)
										assert set(my.items()			) == set(py.items()			)


def 		_UpperCAmelCase				(      ):





					"""simple docstring"""

					def is_public(snake_case			) -> bool:
										return not name.startswith("""_"""			)

					_lowerCAmelCase						=    {name for name in dir({}			) if is_public(snake_case			)}
					_lowerCAmelCase						=    {name for name in dir(HashMap()			) if is_public(snake_case			)}

					assert dict_public_names > hash_public_names




'''simple docstring'''

def 			__UpperCamelCase       (   UpperCAmelCase     ):
 lowercase__				:    Optional[int]  =					1
 for i in range(1		,     num + 1     ):
  fact *= i
 return fact
def 			__UpperCamelCase       (   UpperCAmelCase     ):
 lowercase__				:    Optional[Any]  =					0
 while number > 0:
  lowercase__				:    str  =					number % 10
  sum_of_digits += last_digit
  lowercase__				:    List[str]  =					number // 10  # Removing the last_digit from the given number
 return sum_of_digits
def 			__UpperCamelCase       (   UpperCAmelCase = 100     ):
 lowercase__				:    Optional[int]  =					factorial(UpperCAmelCase     )
 lowercase__				:    Dict  =					split_and_add(UpperCAmelCase     )
 return result


if __name__ == "__main__":
  print(solution(int(input("""Enter the Number: """).strip())))

