code: 
  
  import logging
  import os
  import sys
  import threading
  from logging import (
      CRITICAL,  # NOQA
      DEBUG,  # NOQA
      ERROR,  # NOQA
      FATAL,  # NOQA
      INFO,  # NOQA
      NOTSET,  # NOQA
      WARN,  # NOQA
      WARNING,  # NOQA
  )
  from typing import Optional
  
  from tqdm import auto as tqdm_lib
  
  
  __A   :     Dict      =			threading.Lock()
  __A   :     Optional[logging.Handler]      =			None
  
  __A   :     Optional[int]      =			{
      '''debug''': logging.DEBUG,
      '''info''': logging.INFO,
      '''warning''': logging.WARNING,
      '''error''': logging.ERROR,
      '''critical''': logging.CRITICAL,
  }
  
  __A   :     Dict      =			logging.WARNING
  
  __A   :     List[Any]      =			True
  def 		SCREAMING_SNAKE_CASE__				(							)					-> Union[str, Any]:
  
  
  
      '''simple docstring'''
  
  
  
  
  
  
      lowerCAmelCase				:			Optional[Any]    			=      os.getenv('DIFFUSERS_VERBOSITY',      _UpperCAmelCase				)
      if env_level_str:
          if env_level_str in log_levels:
              return log_levels[env_level_str]
          else:
              logging.getLogger().warning(
                  f"Unknown option DIFFUSERS_VERBOSITY={env_level_str}, "
                  f"has to be one of: { ', '.join(log_levels.keys()				) }"				)
      return _default_log_level
  def 		SCREAMING_SNAKE_CASE__				(							)					-> str:
  
  
  
      '''simple docstring'''
  
  
  
  
  
  
      return __name__.split('.'				)[0]
  def 		SCREAMING_SNAKE_CASE__				(							)					-> logging.Logger:
  
  
  
      '''simple docstring'''
  
  
  
  
  
  
      return logging.getLogger(_get_library_name()				)
  def 		SCREAMING_SNAKE_CASE__				(							)					-> None:
  
  
  
      '''simple docstring'''
  
  
  
  
  
  
      global _default_handler
  
      with _lock:
          if _default_handler:
              # This library has already configured the library root logger.
              return
          lowerCAmelCase				:			str    			=      logging.StreamHandler()  # Set sys.stderr as stream.
          lowerCAmelCase				:			List[Any]    			=      sys.stderr.flush
  
          # Apply our default configuration to the library root logger.
          lowerCAmelCase				:			List[str]    			=      _get_library_root_logger()
          library_root_logger.addHandler(_default_handler				)
          library_root_logger.setLevel(_get_default_logging_level()				)
          lowerCAmelCase				:			Dict    			=      False
  def 		SCREAMING_SNAKE_CASE__				(							)					-> None:
  
  
  
      '''simple docstring'''
  
  
  
  
  
  
      global _default_handler
  
      with _lock:
          if not _default_handler:
              return
  
          lowerCAmelCase				:			Optional[int]    			=      _get_library_root_logger()
          library_root_logger.removeHandler(_default_handler				)
          library_root_logger.setLevel(logging.NOTSET				)
          lowerCAmelCase				:			List[str]    			=      None
  def 		SCREAMING_SNAKE_CASE__				(							)					-> str:
  
  
  
      '''simple docstring'''
  
  
  
  
  
  
      return log_levels
  def 		SCREAMING_SNAKE_CASE__				(							_UpperCAmelCase = None				)					-> logging.Logger:
  
  
  
      '''simple docstring'''
  
  
  
  
  
  
      if name is None:
          lowerCAmelCase				:			Any    			=      _get_library_name()
  
      _configure_library_root_logger()
      return logging.getLogger(_UpperCAmelCase				)
  def 		SCREAMING_SNAKE_CASE__				(							)					-> int:
  
  
  
      '''simple docstring'''
  
  
  
  
  
  
      _configure_library_root_logger()
      return _get_library_root_logger().getEffectiveLevel()
  def 		SCREAMING_SNAKE_CASE__				(							_UpperCAmelCase				)					-> None:
  
  
  
      '''simple docstring'''
  
  
  
  
  
  
      _configure_library_root_logger()
      _get_library_root_logger().setLevel(_UpperCAmelCase				)
  def 		SCREAMING_SNAKE_CASE__				(							)					-> Optional[int]:
  
  
  
      '''simple docstring'''
  
  
  
  
  
  
      return set_verbosity(_UpperCAmelCase				)
  def 		SCREAMING_SNAKE_CASE__				(							)					-> int:
  
  
  
      '''simple docstring'''
  
  
  
  
  
  
      return set_verbosity(_UpperCAmelCase				)
  def 		SCREAMING_SNAKE_CASE__				(							)					-> Union[str, Any]:
  
  
  
      '''simple docstring'''
  
  
  
  
  
  
      return set_verbosity(_UpperCAmelCase				)
  def 		SCREAMING_SNAKE_CASE__				(							)					-> Union[str, Any]:
  
  
  
      '''simple docstring'''
  
  
  
  
  
  
      return set_verbosity(_UpperCAmelCase				)
  def 		SCREAMING_SNAKE_CASE__				(							)					-> None:
  
  
  
      '''simple docstring'''
  
  
  
  
  
  
      _configure_library_root_logger()
  
      assert _default_handler is not None
      _get_library_root_logger().removeHandler(_default_handler				)
  def 		SCREAMING_SNAKE_CASE__				(							)					-> None:
  
  
  
      '''simple docstring'''
  
  
  
  
  
  
      _configure_library_root_logger()
  
      assert _default_handler is not None
      _get_library_root_logger().addHandler(_default_handler				)
  def 		SCREAMING_SNAKE_CASE__				(							_UpperCAmelCase				)					-> None:
  
  
  
      '''simple docstring'''
  
  
  
  
  
  
      _configure_library_root_logger()
  
      assert handler is not None
      _get_library_root_logger().addHandler(_UpperCAmelCase				)
  def 		SCREAMING_SNAKE_CASE__				(							_UpperCAmelCase				)					-> None:
  
  
  
      '''simple docstring'''
  
  
  
  
  
  
      _configure_library_root_logger()
  
      assert handler is not None and handler not in _get_library_root_logger().handlers
      _get_library_root_logger().removeHandler(_UpperCAmelCase				)
  def 		SCREAMING_SNAKE_CASE__				(							)					-> None:
  
  
  
      '''simple docstring'''
  
  
  
  
  
  
      _configure_library_root_logger()
      lowerCAmelCase				:			Optional[int]    			=      False
  def 		SCREAMING_SNAKE_CASE__				(							)					-> None:
  
  
  
      '''simple docstring'''
  
  
  
  
  
  
      _configure_library_root_logger()
      lowerCAmelCase				:			str    			=      True
  def 		SCREAMING_SNAKE_CASE__				(							)					-> None:
  
  
  
      '''simple docstring'''
  
  
  
  
  
  
      lowerCAmelCase				:			Optional[Any]    			=      _get_library_root_logger().handlers
  
      for handler in handlers:
          lowerCAmelCase				:			Any    			=      logging.Formatter('[%(levelname)s|%(filename)s:%(lineno)s] %(asctime)s >> %(message)s'				)
          handler.setFormatter(_UpperCAmelCase				)
  def 		SCREAMING_SNAKE_CASE__				(							)					-> None:
  
  
  
      '''simple docstring'''
  
  
  
  
  
  
      lowerCAmelCase				:			Tuple    			=      _get_library_root_logger().handlers
  
      for handler in handlers:
          handler.setFormatter(_UpperCAmelCase				)
  def 		SCREAMING_SNAKE_CASE__				(							self,      *_UpperCAmelCase,      **_UpperCAmelCase				)					-> str:
  
  
  
      '''simple docstring'''
  
  
  
  
  
  
      lowerCAmelCase				:			Dict    			=      os.getenv('DIFFUSERS_NO_ADVISORY_WARNINGS',      _UpperCAmelCase				)
      if no_advisory_warnings:
          return
      self.warning(*_UpperCAmelCase,      **_UpperCAmelCase				)
  
  
  __A   :     Optional[Any]      =			warning_advice
  
  
  
  
  
  
  class    __A				:
  
  
  
  
  
  
      def __init__(	self			:    List[Any]    ,				*UpperCAmelCase_			:    Union[str, Any]    ,				**UpperCAmelCase_			:    Tuple    ):  # pylint: disable=unused-argument
          lowerCAmelCase				:			Dict    			=      args[0] if args else None
  
  
  
  
  
  
      def __iter__(	self			:    int    ):
          return iter(self._iterator    )
  
  
  
  
  
  
      def __getattr__(	self			:    List[Any]    ,				UpperCAmelCase_			:    Any    ):
  
          def empty_fn(*UpperCAmelCase_			:    Dict    ,				**UpperCAmelCase_			:    str    ):  # pylint: disable=unused-argument
              return
  
          return empty_fn
  
  
  
  
  
  
      def __enter__(	self			:    Union[str, Any]    ):
          return self
  
  
  
  
  
  
      def __exit__(	self			:    Optional[int]    ,				UpperCAmelCase_			:    int    ,				UpperCAmelCase_			:    Tuple    ,				UpperCAmelCase_			:    Optional[Any]    ):
          return
  
  
  
  
  
  
  class    __A				:
  
  
  
  
  
  
      def __call__(	self			:    int    ,				*UpperCAmelCase_			:    Dict    ,				**UpperCAmelCase_			:    List[str]    ):
          if _tqdm_active:
              return tqdm_lib.tqdm(*UpperCAmelCase_    ,				**UpperCAmelCase_    )
          else:
              return EmptyTqdm(*UpperCAmelCase_    ,				**UpperCAmelCase_    )
  
  
  
  
  
  
      def 	lowercase__ (	self			:    List[str]    ,				*UpperCAmelCase_			:    Dict    ,				**UpperCAmelCase_			:    List[Any]    ):
          lowerCAmelCase				:			int    			=      None
          if _tqdm_active:
              return tqdm_lib.tqdm.set_lock(*UpperCAmelCase_    ,				**UpperCAmelCase_    )
  
  
  
  
  
  
      def 	lowercase__ (	self			:    str    ):
          if _tqdm_active:
              return tqdm_lib.tqdm.get_lock()
  
  
  
  __A   :     str      =			_tqdm_cls()
  def 		SCREAMING_SNAKE_CASE__				(							)					-> bool:
  
  
  
      '''simple docstring'''
  
  
  
  
  
  
      global _tqdm_active
      return bool(_tqdm_active				)
  def 		SCREAMING_SNAKE_CASE__				(							)					-> Any:
  
  
  
      '''simple docstring'''
  
  
  
  
  
  
      global _tqdm_active
      lowerCAmelCase				:			List[Any]    			=      True
  
  
  
  
  
  
  def 		SCREAMING_SNAKE_CASE__				(							)					-> int:
  
  
  
      '''simple docstring'''
  
  
  
  
  
  
      global _tqdm_active
      lowerCAmelCase				:			str    			=      False
  
  
  
  
  
  
style_context: 
  
  from __future__ import annotations
  def 		SCREAMING_SNAKE_CASE__				(							_UpperCAmelCase				)					-> set[int]:
  
  
  
      '''simple docstring'''
  
  
  
  
  
  
      lowerCAmelCase				:			List[str]    			=      {1}
      lowerCAmelCase				:			int    			=      [1]
      for _ in range(2,      depth + 1				):
          lowerCAmelCase				:			str    			=      [*previous_coefficients, 0]
          lowerCAmelCase				:			Optional[int]    			=      [0, *previous_coefficients]
          lowerCAmelCase				:			Tuple    			=      []
          for x, y in zip(_UpperCAmelCase,      _UpperCAmelCase				):
              coefficients.add(x + y				)
              previous_coefficients.append(x + y				)
      return coefficients
  def 		SCREAMING_SNAKE_CASE__				(							_UpperCAmelCase				)					-> set[int]:
  
  
  
      '''simple docstring'''
  
  
  
  
  
  
      lowerCAmelCase				:			str    			=      set()
      for number in unique_coefficients:
          lowerCAmelCase				:			Dict    			=      2
          lowerCAmelCase				:			Tuple    			=      number
          while divisor**2 <= copy_number:
              lowerCAmelCase				:			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 		SCREAMING_SNAKE_CASE__				(							_UpperCAmelCase = 51				)					-> int:
  
  
  
      '''simple docstring'''
  
  
  
  
  
  
      lowerCAmelCase				:			int    			=      get_pascal_triangle_unique_coefficients(_UpperCAmelCase				)
      lowerCAmelCase				:			Optional[int]    			=      get_squarefrees(_UpperCAmelCase				)
      return sum(_UpperCAmelCase				)
  
  
  if __name__ == "__main__":
   print(F'{solution() = }')
  
  
  
  
  
  