
def   lowerCamelCase__							(					a      )      ->   bool:
   return credit_card_number.startswith(('''34''', '''35''', '''37''', '''4''', '''5''', '''6''')      )






def   lowerCamelCase__							(					a      )      ->   bool:
   _A:  List[Any]					=       credit_card_number
   _A:  Optional[Any]					=       0
   _A:  Optional[int]					=       len(a      ) - 2
   for i in range(a		,		-1		,		-2      ):
      #  double the value of every second digit
      _A:  List[Any]					=       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
      _A:  List[Any]					=       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      )      ->   bool:
   _A:  List[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_tf_available, is_torch_available


UpperCAmelCase__		:     Any     			=      {'configuration_swin': ['SWIN_PRETRAINED_CONFIG_ARCHIVE_MAP', 'SwinConfig', 'SwinOnnxConfig']}


try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   UpperCAmelCase__		:     Union[str, Any]     			=      [
       'SWIN_PRETRAINED_MODEL_ARCHIVE_LIST',
       'SwinForImageClassification',
       'SwinForMaskedImageModeling',
       'SwinModel',
       'SwinPreTrainedModel',
       'SwinBackbone',
   ]

try:
   if not is_tf_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   UpperCAmelCase__		:     str     			=      [
       'TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST',
       'TFSwinForImageClassification',
       'TFSwinForMaskedImageModeling',
       'TFSwinModel',
       'TFSwinPreTrainedModel',
   ]

if TYPE_CHECKING:
   from .configuration_swin import SWIN_PRETRAINED_CONFIG_ARCHIVE_MAP, SwinConfig, SwinOnnxConfig

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_swin import (
          SWIN_PRETRAINED_MODEL_ARCHIVE_LIST,
          SwinBackbone,
          SwinForImageClassification,
          SwinForMaskedImageModeling,
          SwinModel,
          SwinPreTrainedModel,
      )

   try:
      if not is_tf_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_tf_swin import (
          TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST,
          TFSwinForImageClassification,
          TFSwinForMaskedImageModeling,
          TFSwinModel,
          TFSwinPreTrainedModel,
      )

else:
   import sys

   UpperCAmelCase__		:     Tuple     			=      _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)



