
from math import sqrt



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



def      _a     (   __UpperCamelCase       :  int    ):
			return sum(factors(__UpperCamelCase    )    ) > n



def      _a     (   __UpperCamelCase       :  int    ):
			lowerCAmelCase__ :    str				      =			factors(__UpperCamelCase    )
			lowerCAmelCase__ :    Dict				      =			len(__UpperCamelCase    )
			lowerCAmelCase__ :    Optional[int]				      =			[[0 for i in range(number + 1    )] for j in range(r + 1    )]
			for i in range(r + 1    ):
						lowerCAmelCase__ :    Any				      =			True

			for i in range(1	,number + 1    ):
						lowerCAmelCase__ :    Optional[Any]				      =			False

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

			return subset[r][number] != 0



def      _a     (   __UpperCamelCase       :  int    ):
			return abundant(__UpperCamelCase    ) and not semi_perfect(__UpperCamelCase    )


if __name__ == "__main__":
							import doctest

							doctest.testmod(verbose=True)
							for number in (6_9, 7_0, 7_1):
														print(f"""{number} is {"" if weird(number) else "not "}weird.""")





import abc
import copy
import dataclasses
from dataclasses import dataclass
from typing import ClassVar, Dict, Type, TypeVar

from ..features import Features


A__       :   Tuple   						=					TypeVar("""T""", bound="""TaskTemplate""")





@dataclass(frozen=__UpperCamelCase					)
class 						lowercase       (  abc.ABC					):
					# `task` is not a ClassVar since we want it to be part of the `asdict` output for JSON serialization
					__a					=    42
					__a					=    42
					__a					=    42
					def lowercase_			(		self ,	SCREAMING_SNAKE_CASE__    ):
								"""simple docstring"""







								return copy.deepcopy(self    )
					@property
					def lowercase_			(		self    ):
								"""simple docstring"""







								return Features(**self.input_schema ,	**self.label_schema    )
					@property
					@abc.abstractmethod
					def lowercase_			(		self    ):
								"""simple docstring"""







								raise NotImplementedError
					@classmethod
					def lowercase_			(		cls ,	SCREAMING_SNAKE_CASE__    ):
								"""simple docstring"""







								lowerCAmelCase__ :    List[Any]				      =			{f.name for f in dataclasses.fields(cls    )}
								return cls(**{k: v for k, v in template_dict.items() if k in field_names}    )



