code: 
  
  import glob
  import os
  from typing import Dict, List, Union
  
  import torch
  
  from diffusers.utils import is_safetensors_available
  
  
  if is_safetensors_available():
      import safetensors.torch
  
  from huggingface_hub import snapshot_download
  
  from diffusers import DiffusionPipeline, __version__
  from diffusers.schedulers.scheduling_utils import SCHEDULER_CONFIG_NAME
  from diffusers.utils import CONFIG_NAME, DIFFUSERS_CACHE, ONNX_WEIGHTS_NAME, WEIGHTS_NAME
  
  class 			lowerCamelCase  (					UpperCamelCase__      ):
  
  
    '''simple docstring'''
  
  
  
  
  
  
  
    def __init__(self  ):
  
  
          """simple docstring"""
  
          self.register_to_config()
          super().__init__()
  
  
  
    def    _a			(self       ,					_lowerCamelCase       ,					_lowerCamelCase  ):
  
  
          """simple docstring"""
  
          if dicta == dicta:
                return True
          else:
                UpperCAmelCase__ :       Tuple						=						self._remove_meta_keys(lowerCAmelCase__  )
                UpperCAmelCase__ :       str						=						self._remove_meta_keys(lowerCAmelCase__  )
                if configa == configa:
                      print(F"""Warning !: Mismatch in keys {meta_keysa} and {meta_keysa}."""  )
                      return True
          return False
  
  
  
    def    _a			(self       ,					_lowerCamelCase  ):
  
  
          """simple docstring"""
  
          UpperCAmelCase__ :       Dict						=						[]
          UpperCAmelCase__ :       List[str]						=						config_dict.copy()
          for key in config_dict.keys():
                if key.startswith("""_"""  ):
                      temp_dict.pop(lowerCAmelCase__  )
                      meta_keys.append(lowerCAmelCase__  )
          return (temp_dict, meta_keys)
  
  
  
    @torch.no_grad()
    def    _a			(self       ,					_lowerCamelCase       ,					**_lowerCamelCase  ):
  
  
          """simple docstring"""
  
          UpperCAmelCase__ :       Dict						=						kwargs.pop("""cache_dir"""       ,					lowerCAmelCase__  )
          UpperCAmelCase__ :       Dict						=						kwargs.pop("""resume_download"""       ,					lowerCAmelCase__  )
          UpperCAmelCase__ :       Optional[Any]						=						kwargs.pop("""force_download"""       ,					lowerCAmelCase__  )
          UpperCAmelCase__ :       Tuple						=						kwargs.pop("""proxies"""       ,					lowerCAmelCase__  )
          UpperCAmelCase__ :       Dict						=						kwargs.pop("""local_files_only"""       ,					lowerCAmelCase__  )
          UpperCAmelCase__ :       List[Any]						=						kwargs.pop("""use_auth_token"""       ,					lowerCAmelCase__  )
          UpperCAmelCase__ :       int						=						kwargs.pop("""revision"""       ,					lowerCAmelCase__  )
          UpperCAmelCase__ :       int						=						kwargs.pop("""torch_dtype"""       ,					lowerCAmelCase__  )
          UpperCAmelCase__ :       List[str]						=						kwargs.pop("""device_map"""       ,					lowerCAmelCase__  )
  
          UpperCAmelCase__ :       Union[str, Any]						=						kwargs.pop("""alpha"""       ,					0.5  )
          UpperCAmelCase__ :       Any						=						kwargs.pop("""interp"""       ,					lowerCAmelCase__  )
  
          print("""Received list"""       ,					lowerCAmelCase__  )
          print(F"""Combining with alpha={alpha}, interpolation mode={interp}"""  )
  
          UpperCAmelCase__ :       List[str]						=						len(lowerCAmelCase__  )
          # Ignore result from model_index_json comparision of the two checkpoints
          UpperCAmelCase__ :       Dict						=						kwargs.pop("""force"""       ,					lowerCAmelCase__  )
  
          # If less than 2 checkpoints, nothing to merge. If more than 3, not supported for now.
          if checkpoint_count > 3 or checkpoint_count < 2:
                raise ValueError(
                    """Received incorrect number of checkpoints to merge. Ensure that either 2 or 3 checkpoints are being"""
                    """ passed."""  )
  
          print("""Received the right number of checkpoints"""  )
          # chkpt0, chkpt1 = pretrained_model_name_or_path_list[0:2]
          # chkpt2 = pretrained_model_name_or_path_list[2] if checkpoint_count == 3 else None
  
          # Validate that the checkpoints can be merged
          # Step 1: Load the model config and compare the checkpoints. We'll compare the model_index.json first while ignoring the keys starting with '_'
          UpperCAmelCase__ :       List[Any]						=						[]
          for pretrained_model_name_or_path in pretrained_model_name_or_path_list:
                UpperCAmelCase__ :       int						=						DiffusionPipeline.load_config(
                    lowerCAmelCase__       ,					cache_dir=lowerCAmelCase__       ,					resume_download=lowerCAmelCase__       ,					force_download=lowerCAmelCase__       ,					proxies=lowerCAmelCase__       ,					local_files_only=lowerCAmelCase__       ,					use_auth_token=lowerCAmelCase__       ,					revision=lowerCAmelCase__       ,					)
                config_dicts.append(lowerCAmelCase__  )
  
          UpperCAmelCase__ :       Tuple						=						True
          for idx in range(1       ,					len(lowerCAmelCase__  )  ):
                comparison_result &= self._compare_model_configs(config_dicts[idx - 1]       ,					config_dicts[idx]  )
                if not force and comparison_result is False:
                      raise ValueError("""Incompatible checkpoints. Please check model_index.json for the models."""  )
                      print(config_dicts[0]       ,					config_dicts[1]  )
          print("""Compatible model_index.json files found"""  )
          # Step 2: Basic Validation has succeeded. Let's download the models and save them into our local files.
          UpperCAmelCase__ :       List[str]						=						[]
          for pretrained_model_name_or_path, config_dict in zip(lowerCAmelCase__       ,					lowerCAmelCase__  ):
                UpperCAmelCase__ :       int						=						[k for k in config_dict.keys() if not k.startswith("""_"""  )]
                UpperCAmelCase__ :       Dict						=						[os.path.join(lowerCAmelCase__       ,					"""*"""  ) for k in folder_names]
                allow_patterns += [
                    WEIGHTS_NAME,
                    SCHEDULER_CONFIG_NAME,
                    CONFIG_NAME,
                    ONNX_WEIGHTS_NAME,
                    DiffusionPipeline.config_name,
                ]
                UpperCAmelCase__ :       Dict						=						config_dict.get("""_class_name"""  )
                UpperCAmelCase__ :       Optional[int]						=						{"diffusers": __version__, "pipeline_class": requested_pipeline_class}
  
                UpperCAmelCase__ :       List[str]						=						(
                    pretrained_model_name_or_path
                    if os.path.isdir(lowerCAmelCase__  )
                    else snapshot_download(
                        lowerCAmelCase__       ,					cache_dir=lowerCAmelCase__       ,					resume_download=lowerCAmelCase__       ,					proxies=lowerCAmelCase__       ,					local_files_only=lowerCAmelCase__       ,					use_auth_token=lowerCAmelCase__       ,					revision=lowerCAmelCase__       ,					allow_patterns=lowerCAmelCase__       ,					user_agent=lowerCAmelCase__       ,					)
                )
                print("""Cached Folder"""       ,					lowerCAmelCase__  )
                cached_folders.append(lowerCAmelCase__  )
  
          # Step 3:-
          # Load the first checkpoint as a diffusion pipeline and modify its module state_dict in place
          UpperCAmelCase__ :       Any						=						DiffusionPipeline.from_pretrained(
              cached_folders[0]       ,					torch_dtype=lowerCAmelCase__       ,					device_map=lowerCAmelCase__  )
          final_pipe.to(self.device  )
  
          UpperCAmelCase__ :       List[str]						=						None
          if len(lowerCAmelCase__  ) > 2:
                UpperCAmelCase__ :       Any						=						os.path.join(cached_folders[2]  )
  
          if interp == "sigmoid":
                UpperCAmelCase__ :       Union[str, Any]						=						CheckpointMergerPipeline.sigmoid
          elif interp == "inv_sigmoid":
                UpperCAmelCase__ :       Optional[int]						=						CheckpointMergerPipeline.inv_sigmoid
          elif interp == "add_diff":
                UpperCAmelCase__ :       Any						=						CheckpointMergerPipeline.add_difference
          else:
                UpperCAmelCase__ :       Tuple						=						CheckpointMergerPipeline.weighted_sum
  
          # Find each module's state dict.
          for attr in final_pipe.config.keys():
                if not attr.startswith("""_"""  ):
                      UpperCAmelCase__ :       int						=						os.path.join(cached_folders[1]       ,					lowerCAmelCase__  )
                      if os.path.exists(lowerCAmelCase__  ):
                            UpperCAmelCase__ :       str						=						[
                                *glob.glob(os.path.join(lowerCAmelCase__       ,					"""*.safetensors"""  )  ),
                                *glob.glob(os.path.join(lowerCAmelCase__       ,					"""*.bin"""  )  ),
                            ]
                            UpperCAmelCase__ :       str						=						files[0] if len(lowerCAmelCase__  ) > 0 else None
                      if len(lowerCAmelCase__  ) < 3:
                            UpperCAmelCase__ :       Union[str, Any]						=						None
                      else:
                            UpperCAmelCase__ :       Dict						=						os.path.join(cached_folders[2]       ,					lowerCAmelCase__  )
                            if os.path.exists(lowerCAmelCase__  ):
                                  UpperCAmelCase__ :       List[Any]						=						[
                                      *glob.glob(os.path.join(lowerCAmelCase__       ,					"""*.safetensors"""  )  ),
                                      *glob.glob(os.path.join(lowerCAmelCase__       ,					"""*.bin"""  )  ),
                                  ]
                                  UpperCAmelCase__ :       Optional[Any]						=						files[0] if len(lowerCAmelCase__  ) > 0 else None
                                  # For an attr if both checkpoint_path_1 and 2 are None, ignore.
                                  # If atleast one is present, deal with it according to interp method, of course only if the state_dict keys match.
                      if checkpoint_path_a is None and checkpoint_path_a is None:
                            print(F"""Skipping {attr}: not present in 2nd or 3d model"""  )
                            continue
                      try:
                            UpperCAmelCase__ :       Union[str, Any]						=						getattr(lowerCAmelCase__       ,					lowerCAmelCase__  )
                            if isinstance(lowerCAmelCase__       ,					lowerCAmelCase__  ):  # ignore requires_safety_checker boolean
                                  continue
                            UpperCAmelCase__ :       Tuple						=						getattr(lowerCAmelCase__       ,					"""state_dict"""  )
                            UpperCAmelCase__ :       List[Any]						=						theta_a()
  
                            UpperCAmelCase__ :       Any						=						getattr(lowerCAmelCase__       ,					"""load_state_dict"""  )
                            UpperCAmelCase__ :       List[str]						=						(
                                safetensors.torch.load_file(lowerCAmelCase__  )
                                if (is_safetensors_available() and checkpoint_path_a.endswith(""".safetensors"""  ))
                                else torch.load(lowerCAmelCase__       ,					map_location="""cpu"""  )
                            )
                            UpperCAmelCase__ :       Tuple						=						None
                            if checkpoint_path_a:
                                  UpperCAmelCase__ :       str						=						(
                                      safetensors.torch.load_file(lowerCAmelCase__  )
                                      if (is_safetensors_available() and checkpoint_path_a.endswith(""".safetensors"""  ))
                                      else torch.load(lowerCAmelCase__       ,					map_location="""cpu"""  )
                                  )
  
                            if not theta_a.keys() == theta_a.keys():
                                  print(F"""Skipping {attr}: key mismatch"""  )
                                  continue
                            if theta_a and not theta_a.keys() == theta_a.keys():
                                  print(F"""Skipping {attr}:y mismatch"""  )
                      except Exception as e:
                            print(F"""Skipping {attr} do to an unexpected error: {str(lowerCAmelCase__  )}"""  )
                            continue
                      print(F"""MERGING {attr}"""  )
  
                      for key in theta_a.keys():
                            if theta_a:
                                  UpperCAmelCase__ :       Dict						=						theta_func(theta_a[key]       ,					theta_a[key]       ,					theta_a[key]       ,					lowerCAmelCase__  )
                            else:
                                  UpperCAmelCase__ :       Dict						=						theta_func(theta_a[key]       ,					theta_a[key]       ,					lowerCAmelCase__       ,					lowerCAmelCase__  )
  
                      del theta_a
                      del theta_a
                      update_theta_a(lowerCAmelCase__  )
  
                      del theta_a
          return final_pipe
  
  
  
    @staticmethod
    def    _a			(_lowerCamelCase       ,					_lowerCamelCase       ,					_lowerCamelCase       ,					_lowerCamelCase  ):
  
  
          """simple docstring"""
  
          return ((1 - alpha) * thetaa) + (alpha * thetaa)
  
  
  
    @staticmethod
    def    _a			(_lowerCamelCase       ,					_lowerCamelCase       ,					_lowerCamelCase       ,					_lowerCamelCase  ):
  
  
          """simple docstring"""
  
          UpperCAmelCase__ :       Any						=						alpha * alpha * (3 - (2 * alpha))
          return thetaa + ((thetaa - thetaa) * alpha)
  
  
  
    @staticmethod
    def    _a			(_lowerCamelCase       ,					_lowerCamelCase       ,					_lowerCamelCase       ,					_lowerCamelCase  ):
  
  
          """simple docstring"""
  
          import math
  
          UpperCAmelCase__ :       Dict						=						0.5 - math.sin(math.asin(1.0 - 2.0 * alpha  ) / 3.0  )
          return thetaa + ((thetaa - thetaa) * alpha)
  
  
  
  
    @staticmethod
    def    _a			(_lowerCamelCase       ,					_lowerCamelCase       ,					_lowerCamelCase       ,					_lowerCamelCase  ):
  
  
          """simple docstring"""
  
          return thetaa + (thetaa - thetaa) * (1.0 - alpha)
  
  
style_context: 
  
  """simple docstring"""
  from __future__ import annotations
  
  
  
  
  def 				a__	(	lowerCAmelCase						)  ->   set[int]:
        UpperCAmelCase__ :       List[Any]						=						{1}
        UpperCAmelCase__ :       Optional[int]						=						[1]
        for _ in range(2 ,  depth + 1						):
              UpperCAmelCase__ :       Tuple						=						[*previous_coefficients, 0]
              UpperCAmelCase__ :       List[str]						=						[0, *previous_coefficients]
              UpperCAmelCase__ :       Dict						=						[]
              for x, y in zip(lowerCAmelCase ,  lowerCAmelCase						):
                    coefficients.add(x + y						)
                    previous_coefficients.append(x + y						)
        return coefficients
  
  
  
  
  def 				a__	(	lowerCAmelCase						)  ->   set[int]:
        UpperCAmelCase__ :       List[str]						=						set()
        for number in unique_coefficients:
              UpperCAmelCase__ :       int						=						2
              UpperCAmelCase__ :       List[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(lowerCAmelCase						)
                          break
                    divisor += 1
  
        return unique_coefficients.difference(lowerCAmelCase						)
  
  
  
  
  def 				a__	(	lowerCAmelCase = 51						)  ->   int:
        UpperCAmelCase__ :       Any						=						get_pascal_triangle_unique_coefficients(lowerCAmelCase						)
        UpperCAmelCase__ :       Dict						=						get_squarefrees(lowerCAmelCase						)
        return sum(lowerCAmelCase						)
  
  
  if __name__ == "__main__":
      print(f'''{solution() = }''')
  
  