

def 			lowerCamelCase__			(       _a):
	return credit_card_number.startswith(("34", "35", "37", "4", "5", "6"))

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

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

	return total % 10 == 0

def 			lowerCamelCase__			(       _a):
	SCREAMING_SNAKE_CASE :   str					  =							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(_a) <= 16:
		print(f"{error_message} of its length.")
		return False

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

	if not luhn_validation(_a):
		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')


from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


a_      =     {
    'configuration_swinv2': ['SWINV2_PRETRAINED_CONFIG_ARCHIVE_MAP', 'Swinv2Config'],
}


try:
			if not is_torch_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			a_      =     [
			    'SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST',
			    'Swinv2ForImageClassification',
			    'Swinv2ForMaskedImageModeling',
			    'Swinv2Model',
			    'Swinv2PreTrainedModel',
			]


if TYPE_CHECKING:
			from .configuration_swinva import SWINV2_PRETRAINED_CONFIG_ARCHIVE_MAP, SwinvaConfig

			try:
						if not is_torch_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_swinva import (
						    SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST,
						    SwinvaForImageClassification,
						    SwinvaForMaskedImageModeling,
						    SwinvaModel,
						    SwinvaPreTrainedModel,
						)


else:
			import sys

			a_      =     _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)