






'''simple docstring'''






import secrets
from random import shuffle
from string import ascii_letters, ascii_lowercase, ascii_uppercase, digits, punctuation




def        _SCREAMING_SNAKE_CASE  (				A  :       int = 8  )    -> Union[str, Any]:







   """simple docstring"""
   __snake_case				:      int     							= ascii_letters + digits + punctuation
   return "".join(secrets.choice(_lowerCamelCase  ) for _ in range(_lowerCamelCase  )  )




def        _SCREAMING_SNAKE_CASE  (				A  :       str  ,		A  :       int  )    -> str:







   """simple docstring"""
   # Password Generator = full boot with random_number, random_letters, and
   # random_character FUNCTIONS
   # Put your code here...
   i -= len(_lowerCamelCase  )
   __snake_case				:      List[Any]     							= i // 3
   __snake_case				:      str     							= i % 3
   # chars = chars_incl + random_letters(ascii_letters, i / 3 + remainder) +
   #     random_number(digits, i / 3) + random_characters(punctuation, i / 3)
   __snake_case				:      List[str]     							= (
       chars_incl
       + random(_lowerCamelCase  ,		quotient + remainder  )
       + random(_lowerCamelCase  ,		_lowerCamelCase  )
       + random(_lowerCamelCase  ,		_lowerCamelCase  )
   )
   __snake_case				:      List[Any]     							= list(_lowerCamelCase  )
   shuffle(_lowerCamelCase  )
   return "".join(_lowerCamelCase  )

   # random is a generalised function for letters, characters and numbers




def        _SCREAMING_SNAKE_CASE  (				A  :       str  ,		A  :       int  )    -> Tuple:







   """simple docstring"""
   return "".join(secrets.choice(_lowerCamelCase  ) for _ in range(_lowerCamelCase  )  )




def        _SCREAMING_SNAKE_CASE  (				A  :       Dict  ,		A  :       str  )    -> Optional[int]:







   """simple docstring"""
   pass  # Put your code here...




def        _SCREAMING_SNAKE_CASE  (				A  :       Union[str, Any]  ,		A  :       Optional[Any]  )    -> Dict:







   """simple docstring"""
   pass  # Put your code here...




def        _SCREAMING_SNAKE_CASE  (				A  :       int  ,		A  :       str  )    -> Any:







   """simple docstring"""
   pass  # Put your code here...




def        _SCREAMING_SNAKE_CASE  (				A  :       str  ,		A  :       int = 8  )    -> List[Any]:







   """simple docstring"""

   if len(_lowerCamelCase  ) < min_length:
      # Your Password must be at least 8 characters long
      return False

   __snake_case				:      Dict     							= any(char in ascii_uppercase for char in password  )
   __snake_case				:      Dict     							= any(char in ascii_lowercase for char in password  )
   __snake_case				:      Union[str, Any]     							= any(char in digits for char in password  )
   __snake_case				:      Tuple     							= any(char in punctuation for char in password  )

   return upper and lower and num and spec_char
   # Passwords should contain UPPERCASE, lowerase
   # numbers, and special characters




def        _SCREAMING_SNAKE_CASE  (				)    -> int:







   """simple docstring"""
   __snake_case				:      List[Any]     							= int(input('Please indicate the max length of your password: '  ).strip()  )
   __snake_case				:      str     							= input(
       'Please indicate the characters that must be in your password: '  ).strip()
   print('Password generated:'  ,		password_generator(_lowerCamelCase  )  )
   print(
       'Alternative Password generated:'  ,		alternative_password_generator(_lowerCamelCase  ,		_lowerCamelCase  )  ,		)
   print('[If you are thinking of using this passsword, You better save it.]'  )


if __name__ == "__main__":
      main()







'''simple docstring'''






def        _SCREAMING_SNAKE_CASE  (				A  :       int  )    -> int:







   """simple docstring"""
   __snake_case				:      str     							= 1
   for i in range(1  ,		num + 1  ):
      fact *= i
   return fact




def        _SCREAMING_SNAKE_CASE  (				A  :       int  )    -> int:







   """simple docstring"""
   __snake_case				:      Union[str, Any]     							= 0
   while number > 0:
      __snake_case				:      Dict     							= number % 10
      sum_of_digits += last_digit
      __snake_case				:      Union[str, Any]     							= number // 10  # Removing the last_digit from the given number
   return sum_of_digits




def        _SCREAMING_SNAKE_CASE  (				A  :       int = 1_00  )    -> int:







   """simple docstring"""
   __snake_case				:      List[Any]     							= factorial(A  )
   __snake_case				:      Dict     							= split_and_add(A  )
   return result


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