






from math import sqrt






def    UpperCamelCase__  (   UpperCAmelCase     )     ->		str:







							"""simple docstring"""





							_a  :    List[Any]			=						[1]
							for i in range(2    ,	int(sqrt(_snake_case     )     ) + 1    ,	1     ):
														if number % i == 0:
																					values.append(_snake_case     )
																					if int(number // i     ) != i:
																												values.append(int(number // i     )     )
							return sorted(_snake_case     )






def    UpperCamelCase__  (   UpperCAmelCase     )     ->		Optional[Any]:







							"""simple docstring"""





							return sum(factors(_snake_case     )     ) > n






def    UpperCamelCase__  (   UpperCAmelCase     )     ->		Optional[Any]:







							"""simple docstring"""





							_a  :    str			=						factors(_snake_case     )
							_a  :    Union[str, Any]			=						len(_snake_case     )
							_a  :    Any			=						[[0 for i in range(number + 1     )] for j in range(r + 1     )]
							for i in range(r + 1     ):
														_a  :    Union[str, Any]			=						True

							for i in range(1    ,	number + 1     ):
														_a  :    List[str]			=						False

							for i in range(1    ,	r + 1     ):
														for j in range(1    ,	number + 1     ):
																					if j < values[i - 1]:
																												_a  :    Tuple			=						subset[i - 1][j]
																					else:
																												_a  :    Dict			=						subset[i - 1][j] or subset[i - 1][j - values[i - 1]]

							return subset[r][number] != 0






def    UpperCamelCase__  (   UpperCAmelCase     )     ->		List[str]:







							"""simple docstring"""





							return abundant(_snake_case     ) and not semi_perfect(_snake_case     )


if __name__ == "__main__":
						import doctest

						doctest.testmod(verbose=True)
						for number in (69, 70, 71):
												print(F'''{number} is {"" if weird(number) else "not "}weird.''')





from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


UpperCAmelCase_    ={"""configuration_vilt""": ["""VILT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """ViltConfig"""]}

try:
		if not is_vision_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		UpperCAmelCase_    =["""ViltFeatureExtractor"""]
		UpperCAmelCase_    =["""ViltImageProcessor"""]
		UpperCAmelCase_    =["""ViltProcessor"""]

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		UpperCAmelCase_    =[
		    """VILT_PRETRAINED_MODEL_ARCHIVE_LIST""",
		    """ViltForImageAndTextRetrieval""",
		    """ViltForImagesAndTextClassification""",
		    """ViltForTokenClassification""",
		    """ViltForMaskedLM""",
		    """ViltForQuestionAnswering""",
		    """ViltLayer""",
		    """ViltModel""",
		    """ViltPreTrainedModel""",
		]


if TYPE_CHECKING:
		from .configuration_vilt import VILT_PRETRAINED_CONFIG_ARCHIVE_MAP, ViltConfig

		try:
				if not is_vision_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .feature_extraction_vilt import ViltFeatureExtractor
				from .image_processing_vilt import ViltImageProcessor
				from .processing_vilt import ViltProcessor

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_vilt import (
				    VILT_PRETRAINED_MODEL_ARCHIVE_LIST,
				    ViltForImageAndTextRetrieval,
				    ViltForImagesAndTextClassification,
				    ViltForMaskedLM,
				    ViltForQuestionAnswering,
				    ViltForTokenClassification,
				    ViltLayer,
				    ViltModel,
				    ViltPreTrainedModel,
				)


else:
		import sys

		UpperCAmelCase_    =_LazyModule(__name__, globals()["""__file__"""], _import_structure)



