


'''simple docstring'''






from __future__ import annotations


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


def A_					(				__SCREAMING_SNAKE_CASE :					Dict       )     ->  set[int]:
     __SCREAMING_SNAKE_CASE					:							str			   = set()
     for number in unique_coefficients:
          __SCREAMING_SNAKE_CASE					:							Dict			   = 2
          __SCREAMING_SNAKE_CASE					:							Tuple			   = number
          while divisor**2 <= copy_number:
               __SCREAMING_SNAKE_CASE					:							List[str]			   = 0
               while copy_number % divisor == 0:
                    copy_number //= divisor
                    multiplicity += 1
               if multiplicity >= 2:
                    non_squarefrees.add(_UpperCAmelCase       )
                    break
               divisor += 1

     return unique_coefficients.difference(_UpperCAmelCase       )


def A_					(				__SCREAMING_SNAKE_CASE :					Any = 51       )     ->  int:
     __SCREAMING_SNAKE_CASE					:							int			   = get_pascal_triangle_unique_coefficients(_UpperCAmelCase       )
     __SCREAMING_SNAKE_CASE					:							Optional[int]			   = get_squarefrees(_UpperCAmelCase       )
     return sum(_UpperCAmelCase       )


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






'''simple docstring'''






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

from ..features import Features


_A      =     TypeVar("""T""", bound="""TaskTemplate""")






@dataclass(frozen=snake_case		)
class      SCREAMING_SNAKE_CASE_	( abc.ABC		):
			# `task` is not a ClassVar since we want it to be part of the `asdict` output for JSON serialization
			__a					:      str
			__a					:      ClassVar[Features]
			__a					:      ClassVar[Features]




			def 			_snake_case   (      self					,      lowercase       )			->						T:


								'''simple docstring'''






								return copy.deepcopy(self       )




			@property
			def 			_snake_case   (      self       )			->						Features:


								'''simple docstring'''






								return Features(**self.input_schema					,      **self.label_schema       )




			@property
			@abc.abstractmethod
			def 			_snake_case   (      self       )			->						Dict[str, str]:


								'''simple docstring'''






								raise NotImplementedError




			@classmethod
			def 			_snake_case   (      cls					,      lowercase       )			->						T:


								'''simple docstring'''






								__SCREAMING_SNAKE_CASE					:							Union[str, 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}       )


