'''simple docstring'''





def 	lowerCAmelCase_				(					snake_case_       : str			)    ->      bool:


     '''simple docstring'''




     return credit_card_number.startswith(("34", "35", "37", "4", "5", "6")			)





def 	lowerCAmelCase_				(					snake_case_       : str			)    ->      bool:


     '''simple docstring'''




     UpperCAmelCase_           =   credit_card_number
     UpperCAmelCase_           =   0
     UpperCAmelCase_           =   len(snake_case_			) - 2
     for i in range(snake_case_					,    -1					,    -2			):
          #  double the value of every second digit
          UpperCAmelCase_           =   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
          UpperCAmelCase_           =   cc_number[:i] + str(snake_case_			) + cc_number[i + 1 :]
          total += digit

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

     return total % 10 == 0





def 	lowerCAmelCase_				(					snake_case_       : str			)    ->      bool:


     '''simple docstring'''




     UpperCAmelCase_           =   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(snake_case_			) <= 16:
          print(f"""{error_message} of its length."""			)
          return False

     if not validate_initial_digits(snake_case_			):
          print(f"""{error_message} of its first two digits."""			)
          return False

     if not luhn_validation(snake_case_			):
          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"""






class        __SCREAMING_SNAKE_CASE	:


					'''simple docstring'''





					def __init__(       self							:  Dict,  lowerCamelCase							:  list     )->					None:
								lowerCamelCase__		:		Tuple			=set_counts
								lowerCamelCase__		:		Dict			=max(lowerCamelCase     )
								lowerCamelCase__		:		Union[str, Any]			=len(lowerCamelCase     )
								lowerCamelCase__		:		List[str]			=[1] * num_sets
								lowerCamelCase__		:		str			=list(range(lowerCamelCase     )     )



					def 		snake_case       (       self							:  Tuple,  lowerCamelCase							:  int,  lowerCamelCase							:  int     )->					bool:
								lowerCamelCase__		:		List[Any]			=self.get_parent(lowerCamelCase     )
								lowerCamelCase__		:		str			=self.get_parent(lowerCamelCase     )

								if src_parent == dst_parent:
											return False

								if self.ranks[dst_parent] >= self.ranks[src_parent]:
											self.set_counts[dst_parent] += self.set_counts[src_parent]
											lowerCamelCase__		:		Tuple			=0
											lowerCamelCase__		:		int			=dst_parent
											if self.ranks[dst_parent] == self.ranks[src_parent]:
														self.ranks[dst_parent] += 1
											lowerCamelCase__		:		str			=self.set_counts[dst_parent]
								else:
											self.set_counts[src_parent] += self.set_counts[dst_parent]
											lowerCamelCase__		:		List[Any]			=0
											lowerCamelCase__		:		List[str]			=src_parent
											lowerCamelCase__		:		Dict			=self.set_counts[src_parent]

								lowerCamelCase__		:		str			=max(self.max_set,  lowerCamelCase     )
								return True




					def 		snake_case       (       self							:  Union[str, Any],  lowerCamelCase							:  int     )->					int:
								if self.parents[disj_set] == disj_set:
											return disj_set
								lowerCamelCase__		:		Tuple			=self.get_parent(self.parents[disj_set]     )
								return self.parents[disj_set]




