




"""simple docstring"""

import argparse

import torch
from safetensors.torch import load_file

from diffusers import StableDiffusionPipeline






def 						_snake_case     (					_snake_case							:					Optional[Any]				,  _snake_case							:					Any				,  _snake_case							:					Dict				,  _snake_case							:					Optional[int]				,  _snake_case							:					List[Any]							)    ->					str:






      '''simple docstring'''


      _A					   =   StableDiffusionPipeline.from_pretrained(UpperCamelCase_				,  torch_dtype=torch.floataa							)

      # load LoRA weight from .safetensors
      _A					   =   load_file(UpperCamelCase_							)

      _A					   =   []

      # directly update weight in diffusers model
      for key in state_dict:
            # it is suggested to print out the key, it usually will be something like below
            # "lora_te_text_model_encoder_layers_0_self_attn_k_proj.lora_down.weight"

            # as we have set the alpha beforehand, so just skip
            if ".alpha" in key or key in visited:
                  continue

            if "text" in key:
                  _A					   =   key.split('.'							)[0].split(LORA_PREFIX_TEXT_ENCODER + '_'							)[-1].split('_'							)
                  _A					   =   pipeline.text_encoder
            else:
                  _A					   =   key.split('.'							)[0].split(LORA_PREFIX_UNET + '_'							)[-1].split('_'							)
                  _A					   =   pipeline.unet

            # find the target layer
            _A					   =   layer_infos.pop(0							)
            while len(UpperCamelCase_							) > -1:
                  try:
                        _A					   =   curr_layer.__getattr__(UpperCamelCase_							)
                        if len(UpperCamelCase_							) > 0:
                              _A					   =   layer_infos.pop(0							)
                        elif len(UpperCamelCase_							) == 0:
                              break
                  except Exception:
                        if len(UpperCamelCase_							) > 0:
                              temp_name += "_" + layer_infos.pop(0							)
                        else:
                              _A					   =   layer_infos.pop(0							)

            _A					   =   []
            if "lora_down" in key:
                  pair_keys.append(key.replace('lora_down'				,  'lora_up'							)							)
                  pair_keys.append(UpperCamelCase_							)
            else:
                  pair_keys.append(UpperCamelCase_							)
                  pair_keys.append(key.replace('lora_up'				,  'lora_down'							)							)

            # update weight
            if len(state_dict[pair_keys[0]].shape							) == 4:
                  _A					   =   state_dict[pair_keys[0]].squeeze(3							).squeeze(2							).to(torch.floataa							)
                  _A					   =   state_dict[pair_keys[1]].squeeze(3							).squeeze(2							).to(torch.floataa							)
                  curr_layer.weight.data += alpha * torch.mm(UpperCamelCase_				,  UpperCamelCase_							).unsqueeze(2							).unsqueeze(3							)
            else:
                  _A					   =   state_dict[pair_keys[0]].to(torch.floataa							)
                  _A					   =   state_dict[pair_keys[1]].to(torch.floataa							)
                  curr_layer.weight.data += alpha * torch.mm(UpperCamelCase_				,  UpperCamelCase_							)

            # update visited list
            for item in pair_keys:
                  visited.append(UpperCamelCase_							)

      return pipeline


if __name__ == "__main__":
       a					=			argparse.ArgumentParser()

       parser.add_argument(
           '''--base_model_path''', default=None, type=str, required=True, help='''Path to the base model in diffusers format.'''
       )
       parser.add_argument(
           '''--checkpoint_path''', default=None, type=str, required=True, help='''Path to the checkpoint to convert.'''
       )
       parser.add_argument('''--dump_path''', default=None, type=str, required=True, help='''Path to the output model.''')
       parser.add_argument(
           '''--lora_prefix_unet''', default='''lora_unet''', type=str, help='''The prefix of UNet weight in safetensors'''
       )
       parser.add_argument(
           '''--lora_prefix_text_encoder''',
           default='''lora_te''',
           type=str,
           help='''The prefix of text encoder weight in safetensors''',
       )
       parser.add_argument('''--alpha''', default=0.7_5, type=float, help='''The merging ratio in W = W0 + alpha * deltaW''')
       parser.add_argument(
           '''--to_safetensors''', action='''store_true''', help='''Whether to store pipeline in safetensors format or not.'''
       )
       parser.add_argument('''--device''', type=str, help='''Device to use (e.g. cpu, cuda:0, cuda:1, etc.)''')

       a					=			parser.parse_args()

       a					=			args.base_model_path
       a					=			args.checkpoint_path
       a					=			args.dump_path
       a					=			args.lora_prefix_unet
       a					=			args.lora_prefix_text_encoder
       a					=			args.alpha

       a					=			convert(base_model_path, checkpoint_path, lora_prefix_unet, lora_prefix_text_encoder, alpha)

       a					=			pipe.to(args.device)
       pipe.save_pretrained(args.dump_path, safe_serialization=args.to_safetensors)




"""simple docstring"""





from math import sqrt




def   _A  (  UpperCamelCase_     :       int)	->						int:
   '''simple docstring'''


   __lowercase								=						0
   for i in range(1,			int(sqrt(UpperCamelCase_) + 1)):
      if n % i == 0 and i != sqrt(UpperCamelCase_):
         total += i + n // i
      elif i == sqrt(UpperCamelCase_):
         total += i
   return total - n




def   _A  (  UpperCamelCase_     :       int = 10000)	->						int:
   '''simple docstring'''


   __lowercase								=						sum(
       i
       for i in range(1,			UpperCamelCase_)
       if sum_of_divisors(sum_of_divisors(UpperCamelCase_)) == i and sum_of_divisors(UpperCamelCase_) != i)
   return total


if __name__ == "__main__":
   print(solution(int(str(input()).strip())))




