code: 
  """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() = }""")
  
  
  
style_context: 
  """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_						)
  
  
  