
"""simple docstring"""





from __future__ import annotations







def 			__a  (	__lowerCamelCase						):
   UpperCAmelCase_      :      int      =					{1}
   UpperCAmelCase_      :      Optional[Any]      =					[1]
   for _ in range(2,	depth + 1						):
      UpperCAmelCase_      :      Optional[int]      =					[*previous_coefficients, 0]
      UpperCAmelCase_      :      List[str]      =					[0, *previous_coefficients]
      UpperCAmelCase_      :      Dict      =					[]
      for x, y in zip(lowercase__,	lowercase__						):
         coefficients.add(x + y						)
         previous_coefficients.append(x + y						)
   return coefficients







def 			__a  (	__lowerCamelCase						):
   UpperCAmelCase_      :      Tuple      =					set()
   for number in unique_coefficients:
      UpperCAmelCase_      :      List[Any]      =					2
      UpperCAmelCase_      :      Optional[Any]      =					number
      while divisor**2 <= copy_number:
         UpperCAmelCase_      :      Tuple      =					0
         while copy_number % divisor == 0:
            copy_number //= divisor
            multiplicity += 1
         if multiplicity >= 2:
            non_squarefrees.add(lowercase__						)
            break
         divisor += 1

   return unique_coefficients.difference(lowercase__						)







def 			__a  (	__lowerCamelCase = 51						):
   UpperCAmelCase_      :      Union[str, Any]      =					get_pascal_triangle_unique_coefficients(lowercase__						)
   UpperCAmelCase_      :      str      =					get_squarefrees(lowercase__						)
   return sum(lowercase__						)


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




"""simple docstring"""





from hashlib import mda, shaaaa

_a	 =							(shaaaa, mda)


class A_			:




  '''simple docstring'''







  def __init__(	self       ,     lowercase_ = 8						):

     """simple docstring"""
     UpperCAmelCase_      :      List[str]      =					0B0
     UpperCAmelCase_      :      Union[str, Any]      =					size







  def  UpperCamelCase__      (	self       ,     lowercase_						):

     """simple docstring"""
     UpperCAmelCase_      :      Union[str, Any]      =					self.hash_(lowercase_						)
     self.bitarray |= h







  def  UpperCamelCase__      (	self       ,     lowercase_						):

     """simple docstring"""
     UpperCAmelCase_      :      Optional[int]      =					self.hash_(lowercase_						)
     return (h & self.bitarray) == h







  def __contains__(	self       ,     lowercase_						):

     """simple docstring"""
     return self.exists(lowercase_						)







  def  UpperCamelCase__      (	self       ,     lowercase_						):

     """simple docstring"""
     UpperCAmelCase_      :      str      =					bin(lowercase_						)[2:]
     return res.zfill(self.size						)







  @property
  def  UpperCamelCase__      (	self						):

     """simple docstring"""
     return self.format_bin(self.bitarray						)







  def  UpperCamelCase__      (	self       ,     lowercase_						):

     """simple docstring"""
     UpperCAmelCase_      :      List[str]      =					0B0
     for func in HASH_FUNCTIONS:
        UpperCAmelCase_      :      str      =					(
            int.from_bytes(func(value.encode()						).digest()       ,     "little"						) % self.size
        )
        res |= 2**position
     return res







  def  UpperCamelCase__      (	self       ,     lowercase_						):

     """simple docstring"""
     return self.format_bin(self.hash_(lowercase_						)						)







  @property
  def  UpperCamelCase__      (	self						):

     """simple docstring"""
     UpperCAmelCase_      :      Optional[Any]      =					bin(self.bitarray						).count("1"						)
     return (n_ones / self.size) ** len(lowercase_						)


