





def    A__(		__lowerCAmelCase			):
				return credit_card_number.startswith(('34', '35', '37', '4', '5', '6')			)

def    A__(		__lowerCAmelCase			):
				_snake_case			:      Any	    = credit_card_number
				_snake_case			:      List[Any]	    = 0
				_snake_case			:      Tuple	    = len(__lowerCAmelCase			) - 2
				for i in range(__lowerCAmelCase						,      -1						,      -2			):
								#  double the value of every second digit
								_snake_case			:      Tuple	    = int(cc_number[i]			)
								digit *= 2
								# If doubling of a number results in a two digit number
								# i.e greater than 9(e.g., 6 × 2 = 12),
								# then add the digits of the product (e.g., 12: 1 + 2 = 3, 15: 1 + 5 = 6),
								# to get a single digit number.
								if digit > 9:
												digit %= 10
												digit += 1
								_snake_case			:      List[str]	    = cc_number[:i] + str(__lowerCAmelCase			) + cc_number[i + 1 :]
								total += digit

				# Sum up the remaining digits
				for i in range(len(__lowerCAmelCase			) - 1						,      -1						,      -2			):
								total += int(cc_number[i]			)

				return total % 10 == 0

def    A__(		__lowerCAmelCase			):
				_snake_case			:      List[Any]	    = F'''{credit_card_number} is an invalid credit card number because'''
				if not credit_card_number.isdigit():
								print(F'''{error_message} it has nonnumerical characters.'''			)
								return False

				if not 13 <= len(__lowerCAmelCase			) <= 16:
								print(F'''{error_message} of its length.'''			)
								return False

				if not validate_initial_digits(__lowerCAmelCase			):
								print(F'''{error_message} of its first two digits.'''			)
								return False

				if not luhn_validation(__lowerCAmelCase			):
								print(F'''{error_message} it fails the Luhn check.'''			)
								return False

				print(F'''{credit_card_number} is a valid credit card number.'''			)
				return True


if __name__ == "__main__":
		import doctest

		doctest.testmod()
		validate_credit_card_number('''4111111111111111''')
		validate_credit_card_number('''32323''')







"""simple docstring"""



from typing import List

from .keymap import KEYMAP, get_character

def  _A(		lowerCAmelCase							):

							def decorator(lowerCAmelCase							):
														A__       :     Any								=			getattr(lowerCAmelCase			,  """handle_key"""			,  []							)
														handle += [key]
														setattr(lowerCAmelCase			,  """handle_key"""			,  lowerCAmelCase							)
														return func

							return decorator

def  _A(		*lowerCAmelCase							):

							def decorator(lowerCAmelCase							):
														A__       :     Optional[Any]								=			getattr(lowerCAmelCase			,  """handle_key"""			,  []							)
														handle += keys
														setattr(lowerCAmelCase			,  """handle_key"""			,  lowerCAmelCase							)
														return func

							return decorator
class 						__UpperCAmelCase    (__A     ):







			'''simple docstring'''





			def __new__(			cls   ,      snake_case_   ,      snake_case_   ,      snake_case_							):







										'''simple docstring'''


										A__       :     Union[str, Any]								=			super().__new__(cls   ,      snake_case_   ,      snake_case_   ,      snake_case_							)
										if not hasattr(snake_case_   ,      """key_handler"""							):
																	setattr(snake_case_   ,      """key_handler"""   ,      {}							)
										setattr(snake_case_   ,      """handle_input"""   ,      KeyHandler.handle_input							)

										for value in attrs.values():
																	A__       :     Dict								=			getattr(snake_case_   ,      """handle_key"""   ,      []							)
																	for key in handled_keys:
																								A__       :     Optional[Any]								=			value
										return new_cls





			@staticmethod
			def 		lowerCamelCase					(			cls							):







										'''simple docstring'''


										A__       :     int								=			get_character()
										if char != KEYMAP["undefined"]:
																	A__       :     Union[str, Any]								=			ord(snake_case_							)
										A__       :     int								=			cls.key_handler.get(snake_case_							)
										if handler:
																	A__       :     int								=			char
																	return handler(cls							)
										else:
																	return None





def  _A(		cls							):
							return KeyHandler(cls.__name__			,  cls.__bases__			,  cls.__dict__.copy()							)





