


from __future__ import annotations



def   SCREAMING_SNAKE_CASE__						(							snake_case_	)			->							set[int]:
				A__     :							Any   				={1}
				A__     :							Optional[int]   				=[1]
				for _ in range(2,	depth + 1	):
								A__     :							str   				=[*previous_coefficients, 0]
								A__     :							Optional[int]   				=[0, *previous_coefficients]
								A__     :							List[Any]   				=[]
								for x, y in zip(snake_case_,	snake_case_	):
												coefficients.add(x + y	)
												previous_coefficients.append(x + y	)
				return coefficients



def   SCREAMING_SNAKE_CASE__						(							snake_case_	)			->							set[int]:
				A__     :							List[str]   				=set()
				for number in unique_coefficients:
								A__     :							List[str]   				=2
								A__     :							Optional[Any]   				=number
								while divisor**2 <= copy_number:
												A__     :							str   				=0
												while copy_number % divisor == 0:
																copy_number //= divisor
																multiplicity += 1
												if multiplicity >= 2:
																non_squarefrees.add(snake_case_	)
																break
												divisor += 1

				return unique_coefficients.difference(snake_case_	)



def   SCREAMING_SNAKE_CASE__						(							snake_case_ = 5_1	)			->							int:
				A__     :							Tuple   				=get_pascal_triangle_unique_coefficients(snake_case_	)
				A__     :							Optional[Any]   				=get_squarefrees(snake_case_	)
				return sum(snake_case_	)


if __name__ == "__main__":
						print(F"{solution() = }")







from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
)


__lowerCamelCase       :       str				   =			{
    "configuration_align": [
        "ALIGN_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "AlignConfig",
        "AlignTextConfig",
        "AlignVisionConfig",
    ],
    "processing_align": ["AlignProcessor"],
}

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__lowerCamelCase       :       Dict				   =			[
						    "ALIGN_PRETRAINED_MODEL_ARCHIVE_LIST",
						    "AlignModel",
						    "AlignPreTrainedModel",
						    "AlignTextModel",
						    "AlignVisionModel",
						]

if TYPE_CHECKING:
						from .configuration_align import (
						    ALIGN_PRETRAINED_CONFIG_ARCHIVE_MAP,
						    AlignConfig,
						    AlignTextConfig,
						    AlignVisionConfig,
						)
						from .processing_align import AlignProcessor

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_align import (
												    ALIGN_PRETRAINED_MODEL_ARCHIVE_LIST,
												    AlignModel,
												    AlignPreTrainedModel,
												    AlignTextModel,
												    AlignVisionModel,
												)

else:
						import sys

						__lowerCamelCase       :       List[str]				   =			_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)



