

import gc
import os
import tempfile
import unittest

import torch
import torch.nn as nn
import torch.nn.functional as F
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, DDIMScheduler, StableDiffusionPipeline, UNetaDConditionModel
from diffusers.loaders import AttnProcsLayers, LoraLoaderMixin
from diffusers.models.attention_processor import (
    Attention,
    AttnProcessor,
    AttnProcessor2_0,
    LoRAAttnProcessor,
    LoRAAttnProcessor2_0,
    LoRAXFormersAttnProcessor,
    XFormersAttnProcessor,
)
from diffusers.utils import TEXT_ENCODER_ATTN_MODULE, floats_tensor, torch_device




def        __UpperCamelCase     (      _A					:							nn.Module		)				->int:



							"""simple docstring"""
							lowerCamelCase_								={}
							for name in unet.attn_processors.keys():
														lowerCamelCase_								=None if name.endswith("""attn1.processor"""		) else unet.config.cross_attention_dim
														if name.startswith("""mid_block"""		):
																					lowerCamelCase_								=unet.config.block_out_channels[-1]
														elif name.startswith("""up_blocks"""		):
																					lowerCamelCase_								=int(name[len("""up_blocks."""		)]		)
																					lowerCamelCase_								=list(reversed(unet.config.block_out_channels		)		)[block_id]
														elif name.startswith("""down_blocks"""		):
																					lowerCamelCase_								=int(name[len("""down_blocks."""		)]		)
																					lowerCamelCase_								=unet.config.block_out_channels[block_id]
														lowerCamelCase_								=(
														    LoRAAttnProcessor2_0 if hasattr(_A      ,  """scaled_dot_product_attention"""		) else LoRAAttnProcessor
														)
														lowerCamelCase_								=lora_attn_processor_class(
														    hidden_size=_A      ,  cross_attention_dim=_A		)
							lowerCamelCase_								=AttnProcsLayers(_A		)
							return lora_attn_procs, unet_lora_layers




def        __UpperCamelCase     (      _A					:							nn.Module		)				->List[str]:



							"""simple docstring"""
							lowerCamelCase_								={}
							lowerCamelCase_								=(
							    LoRAAttnProcessor2_0 if hasattr(_A      ,  """scaled_dot_product_attention"""		) else LoRAAttnProcessor
							)
							for name, module in text_encoder.named_modules():
														if name.endswith(_A		):
																					lowerCamelCase_								=lora_attn_processor_class(
																					    hidden_size=module.out_proj.out_features      ,  cross_attention_dim=_A		)
							return text_lora_attn_procs




def        __UpperCamelCase     (      _A					:							nn.Module		)				->Optional[Any]:



							"""simple docstring"""
							lowerCamelCase_								=create_text_encoder_lora_attn_procs(_A		)
							lowerCamelCase_								=AttnProcsLayers(_A		)
							return text_encoder_lora_layers




def        __UpperCamelCase     (      _A					:							List[str]      ,  _A					:							Optional[Any]=False		)				->int:



							"""simple docstring"""
							for _, attn_proc in text_lora_attn_procs.items():
														# set up.weights
														for layer_name, layer_module in attn_proc.named_modules():
																					if layer_name.endswith("""_lora"""		):
																												lowerCamelCase_								=(
																												    torch.randn_like(layer_module.up.weight		)
																												    if randn_weight
																												    else torch.zeros_like(layer_module.up.weight		)
																												)
																												lowerCamelCase_								=torch.nn.Parameter(_A		)






class 			_SCREAMING_SNAKE_CASE      (  unittest.TestCase):







						def        _snake_case				(			self							)->							Optional[int]:
													torch.manual_seed(0							)
													lowerCamelCase_								=UNetaDConditionModel(
													    block_out_channels=(32, 64)     ,						layers_per_block=2     ,						sample_size=32     ,						in_channels=4     ,						out_channels=4     ,						down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")     ,						up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")     ,						cross_attention_dim=32     ,						)
													lowerCamelCase_								=DDIMScheduler(
													    beta_start=0.0_0_0_8_5     ,						beta_end=0.0_1_2     ,						beta_schedule="""scaled_linear"""     ,						clip_sample=_SCREAMING_SNAKE_CASE     ,						set_alpha_to_one=_SCREAMING_SNAKE_CASE     ,						steps_offset=1     ,						)
													torch.manual_seed(0							)
													lowerCamelCase_								=AutoencoderKL(
													    block_out_channels=[32, 64]     ,						in_channels=3     ,						out_channels=3     ,						down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]     ,						up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]     ,						latent_channels=4     ,						)
													lowerCamelCase_								=CLIPTextConfig(
													    bos_token_id=0     ,						eos_token_id=2     ,						hidden_size=32     ,						intermediate_size=37     ,						layer_norm_eps=1E-05     ,						num_attention_heads=4     ,						num_hidden_layers=5     ,						pad_token_id=1     ,						vocab_size=1000     ,						)
													lowerCamelCase_								=CLIPTextModel(_SCREAMING_SNAKE_CASE							)
													lowerCamelCase_								=CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""							)

													lowerCamelCase_	,   lowerCamelCase_								=create_unet_lora_layers(_SCREAMING_SNAKE_CASE							)
													lowerCamelCase_								=create_text_encoder_lora_layers(_SCREAMING_SNAKE_CASE							)

													lowerCamelCase_								={
													    """unet""": unet,
													    """scheduler""": scheduler,
													    """vae""": vae,
													    """text_encoder""": text_encoder,
													    """tokenizer""": tokenizer,
													    """safety_checker""": None,
													    """feature_extractor""": None,
													}
													lowerCamelCase_								={
													    """unet_lora_layers""": unet_lora_layers,
													    """text_encoder_lora_layers""": text_encoder_lora_layers,
													    """unet_lora_attn_procs""": unet_lora_attn_procs,
													}
													return pipeline_components, lora_components







						def        _snake_case				(			self							)->							Optional[Any]:
													lowerCamelCase_								=1
													lowerCamelCase_								=10
													lowerCamelCase_								=4
													lowerCamelCase_								=(32, 32)

													lowerCamelCase_								=torch.manual_seed(0							)
													lowerCamelCase_								=floats_tensor((batch_size, num_channels) + sizes							)
													lowerCamelCase_								=torch.randint(1     ,						_SCREAMING_SNAKE_CASE     ,						size=(batch_size, sequence_length)     ,						generator=_SCREAMING_SNAKE_CASE							)

													lowerCamelCase_								={
													    """prompt""": """A painting of a squirrel eating a burger""",
													    """generator""": generator,
													    """num_inference_steps""": 2,
													    """guidance_scale""": 6.0,
													    """output_type""": """numpy""",
													}

													return noise, input_ids, pipeline_inputs

													# copied from: https://colab.research.google.com/gist/sayakpaul/df2ef6e1ae6d8c10a49d859883b10860/scratchpad.ipynb







						def        _snake_case				(			self							)->							List[Any]:
													lowerCamelCase_								=77

													lowerCamelCase_								=torch.randint(2     ,						56     ,						size=(1, max_seq_length)     ,						generator=torch.manual_seed(0							)							)

													lowerCamelCase_								={}
													lowerCamelCase_								=inputs
													return prepared_inputs







						def        _snake_case				(			self     ,						_SCREAMING_SNAKE_CASE							)->							Optional[Any]:
													lowerCamelCase_	,   lowerCamelCase_								=self.get_dummy_components()
													LoraLoaderMixin.save_lora_weights(
													    save_directory=_SCREAMING_SNAKE_CASE     ,						unet_lora_layers=lora_components["""unet_lora_layers"""]     ,						text_encoder_lora_layers=lora_components["""text_encoder_lora_layers"""]     ,						)
													self.assertTrue(os.path.isfile(os.path.join(_SCREAMING_SNAKE_CASE     ,						"""pytorch_lora_weights.bin"""							)							)							)







						def        _snake_case				(			self							)->							Union[str, Any]:
													lowerCamelCase_	,   lowerCamelCase_								=self.get_dummy_components()
													lowerCamelCase_								=StableDiffusionPipeline(**_SCREAMING_SNAKE_CASE							)
													lowerCamelCase_								=sd_pipe.to(_SCREAMING_SNAKE_CASE							)
													sd_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE							)

													lowerCamelCase_	,   lowerCamelCase_	,   lowerCamelCase_								=self.get_dummy_inputs()

													lowerCamelCase_								=sd_pipe(**_SCREAMING_SNAKE_CASE							).images
													lowerCamelCase_								=original_images[0, -3:, -3:, -1]

													with tempfile.TemporaryDirectory() as tmpdirname:
																				LoraLoaderMixin.save_lora_weights(
																				    save_directory=_SCREAMING_SNAKE_CASE     ,						unet_lora_layers=lora_components["""unet_lora_layers"""]     ,						text_encoder_lora_layers=lora_components["""text_encoder_lora_layers"""]     ,						)
																				self.assertTrue(os.path.isfile(os.path.join(_SCREAMING_SNAKE_CASE     ,						"""pytorch_lora_weights.bin"""							)							)							)
																				sd_pipe.load_lora_weights(_SCREAMING_SNAKE_CASE							)

													lowerCamelCase_								=sd_pipe(**_SCREAMING_SNAKE_CASE							).images
													lowerCamelCase_								=lora_images[0, -3:, -3:, -1]

													# Outputs shouldn't match.
													self.assertFalse(torch.allclose(torch.from_numpy(_SCREAMING_SNAKE_CASE							)     ,						torch.from_numpy(_SCREAMING_SNAKE_CASE							)							)							)







						def        _snake_case				(			self							)->							str:
													lowerCamelCase_	,   lowerCamelCase_								=self.get_dummy_components()
													lowerCamelCase_								=StableDiffusionPipeline(**_SCREAMING_SNAKE_CASE							)
													lowerCamelCase_								=sd_pipe.to(_SCREAMING_SNAKE_CASE							)
													sd_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE							)

													lowerCamelCase_	,   lowerCamelCase_	,   lowerCamelCase_								=self.get_dummy_inputs()

													lowerCamelCase_								=sd_pipe(**_SCREAMING_SNAKE_CASE							).images
													lowerCamelCase_								=original_images[0, -3:, -3:, -1]

													with tempfile.TemporaryDirectory() as tmpdirname:
																				LoraLoaderMixin.save_lora_weights(
																				    save_directory=_SCREAMING_SNAKE_CASE     ,						unet_lora_layers=lora_components["""unet_lora_layers"""]     ,						text_encoder_lora_layers=lora_components["""text_encoder_lora_layers"""]     ,						safe_serialization=_SCREAMING_SNAKE_CASE     ,						)
																				self.assertTrue(os.path.isfile(os.path.join(_SCREAMING_SNAKE_CASE     ,						"""pytorch_lora_weights.safetensors"""							)							)							)
																				sd_pipe.load_lora_weights(_SCREAMING_SNAKE_CASE							)

													lowerCamelCase_								=sd_pipe(**_SCREAMING_SNAKE_CASE							).images
													lowerCamelCase_								=lora_images[0, -3:, -3:, -1]

													# Outputs shouldn't match.
													self.assertFalse(torch.allclose(torch.from_numpy(_SCREAMING_SNAKE_CASE							)     ,						torch.from_numpy(_SCREAMING_SNAKE_CASE							)							)							)







						def        _snake_case				(			self							)->							Union[str, Any]:
													lowerCamelCase_	,   lowerCamelCase_								=self.get_dummy_components()
													lowerCamelCase_								=lora_components["""unet_lora_attn_procs"""]
													lowerCamelCase_								=StableDiffusionPipeline(**_SCREAMING_SNAKE_CASE							)
													lowerCamelCase_								=sd_pipe.to(_SCREAMING_SNAKE_CASE							)
													sd_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE							)

													lowerCamelCase_	,   lowerCamelCase_	,   lowerCamelCase_								=self.get_dummy_inputs()

													lowerCamelCase_								=sd_pipe(**_SCREAMING_SNAKE_CASE							).images
													lowerCamelCase_								=original_images[0, -3:, -3:, -1]

													with tempfile.TemporaryDirectory() as tmpdirname:
																				lowerCamelCase_								=sd_pipe.unet
																				unet.set_attn_processor(_SCREAMING_SNAKE_CASE							)
																				unet.save_attn_procs(_SCREAMING_SNAKE_CASE							)
																				self.assertTrue(os.path.isfile(os.path.join(_SCREAMING_SNAKE_CASE     ,						"""pytorch_lora_weights.bin"""							)							)							)
																				sd_pipe.load_lora_weights(_SCREAMING_SNAKE_CASE							)

													lowerCamelCase_								=sd_pipe(**_SCREAMING_SNAKE_CASE							).images
													lowerCamelCase_								=lora_images[0, -3:, -3:, -1]

													# Outputs shouldn't match.
													self.assertFalse(torch.allclose(torch.from_numpy(_SCREAMING_SNAKE_CASE							)     ,						torch.from_numpy(_SCREAMING_SNAKE_CASE							)							)							)







						def        _snake_case				(			self							)->							str:
													lowerCamelCase_	,   lowerCamelCase_								=self.get_dummy_components()
													lowerCamelCase_								=StableDiffusionPipeline(**_SCREAMING_SNAKE_CASE							)

													lowerCamelCase_								=self.get_dummy_tokens()

													# inference without lora
													lowerCamelCase_								=pipe.text_encoder(**_SCREAMING_SNAKE_CASE							)[0]
													assert outputs_without_lora.shape == (1, 77, 32)

													# create lora_attn_procs with zeroed out up.weights
													lowerCamelCase_								=create_text_encoder_lora_attn_procs(pipe.text_encoder							)
													set_lora_up_weights(_SCREAMING_SNAKE_CASE     ,						randn_weight=_SCREAMING_SNAKE_CASE							)

													# monkey patch
													pipe._modify_text_encoder(_SCREAMING_SNAKE_CASE							)

													# verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
													del text_attn_procs
													gc.collect()

													# inference with lora
													lowerCamelCase_								=pipe.text_encoder(**_SCREAMING_SNAKE_CASE							)[0]
													assert outputs_with_lora.shape == (1, 77, 32)

													assert torch.allclose(
													    _SCREAMING_SNAKE_CASE     ,						_SCREAMING_SNAKE_CASE							), "lora_up_weight are all zero, so the lora outputs should be the same to without lora outputs"

													# create lora_attn_procs with randn up.weights
													lowerCamelCase_								=create_text_encoder_lora_attn_procs(pipe.text_encoder							)
													set_lora_up_weights(_SCREAMING_SNAKE_CASE     ,						randn_weight=_SCREAMING_SNAKE_CASE							)

													# monkey patch
													pipe._modify_text_encoder(_SCREAMING_SNAKE_CASE							)

													# verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
													del text_attn_procs
													gc.collect()

													# inference with lora
													lowerCamelCase_								=pipe.text_encoder(**_SCREAMING_SNAKE_CASE							)[0]
													assert outputs_with_lora.shape == (1, 77, 32)

													assert not torch.allclose(
													    _SCREAMING_SNAKE_CASE     ,						_SCREAMING_SNAKE_CASE							), "lora_up_weight are not zero, so the lora outputs should be different to without lora outputs"







						def        _snake_case				(			self							)->							Tuple:
													lowerCamelCase_	,   lowerCamelCase_								=self.get_dummy_components()
													lowerCamelCase_								=StableDiffusionPipeline(**_SCREAMING_SNAKE_CASE							)

													lowerCamelCase_								=self.get_dummy_tokens()

													# inference without lora
													lowerCamelCase_								=pipe.text_encoder(**_SCREAMING_SNAKE_CASE							)[0]
													assert outputs_without_lora.shape == (1, 77, 32)

													# create lora_attn_procs with randn up.weights
													lowerCamelCase_								=create_text_encoder_lora_attn_procs(pipe.text_encoder							)
													set_lora_up_weights(_SCREAMING_SNAKE_CASE     ,						randn_weight=_SCREAMING_SNAKE_CASE							)

													# monkey patch
													pipe._modify_text_encoder(_SCREAMING_SNAKE_CASE							)

													# verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
													del text_attn_procs
													gc.collect()

													# inference with lora
													lowerCamelCase_								=pipe.text_encoder(**_SCREAMING_SNAKE_CASE							)[0]
													assert outputs_with_lora.shape == (1, 77, 32)

													assert not torch.allclose(
													    _SCREAMING_SNAKE_CASE     ,						_SCREAMING_SNAKE_CASE							), "lora outputs should be different to without lora outputs"

													# remove monkey patch
													pipe._remove_text_encoder_monkey_patch()

													# inference with removed lora
													lowerCamelCase_								=pipe.text_encoder(**_SCREAMING_SNAKE_CASE							)[0]
													assert outputs_without_lora_removed.shape == (1, 77, 32)

													assert torch.allclose(
													    _SCREAMING_SNAKE_CASE     ,						_SCREAMING_SNAKE_CASE							), "remove lora monkey patch should restore the original outputs"







						def        _snake_case				(			self							)->							Dict:
													lowerCamelCase_	,   lowerCamelCase_								=self.get_dummy_components()
													lowerCamelCase_								=StableDiffusionPipeline(**_SCREAMING_SNAKE_CASE							)
													lowerCamelCase_								=sd_pipe.to(_SCREAMING_SNAKE_CASE							)
													sd_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE							)

													lowerCamelCase_	,   lowerCamelCase_	,   lowerCamelCase_								=self.get_dummy_inputs()

													with tempfile.TemporaryDirectory() as tmpdirname:
																				LoraLoaderMixin.save_lora_weights(
																				    save_directory=_SCREAMING_SNAKE_CASE     ,						unet_lora_layers=lora_components["""unet_lora_layers"""]     ,						text_encoder_lora_layers=lora_components["""text_encoder_lora_layers"""]     ,						)
																				self.assertTrue(os.path.isfile(os.path.join(_SCREAMING_SNAKE_CASE     ,						"""pytorch_lora_weights.bin"""							)							)							)
																				sd_pipe.load_lora_weights(_SCREAMING_SNAKE_CASE							)

													lowerCamelCase_								=sd_pipe(**_SCREAMING_SNAKE_CASE							).images
													lowerCamelCase_								=lora_images[0, -3:, -3:, -1]

													lowerCamelCase_								=sd_pipe(**_SCREAMING_SNAKE_CASE     ,						cross_attention_kwargs={"""scale""": 0.5}							).images
													lowerCamelCase_								=lora_images_with_scale[0, -3:, -3:, -1]

													# Outputs shouldn't match.
													self.assertFalse(
													    torch.allclose(torch.from_numpy(_SCREAMING_SNAKE_CASE							)     ,						torch.from_numpy(_SCREAMING_SNAKE_CASE							)							)							)







						def        _snake_case				(			self							)->							List[Any]:
													with tempfile.TemporaryDirectory() as tmpdirname:
																				self.create_lora_weight_file(_SCREAMING_SNAKE_CASE							)

																				lowerCamelCase_	,   lowerCamelCase_								=self.get_dummy_components()
																				lowerCamelCase_								=StableDiffusionPipeline(**_SCREAMING_SNAKE_CASE							)
																				lowerCamelCase_								=sd_pipe.to(_SCREAMING_SNAKE_CASE							)
																				sd_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE							)

																				# check if vanilla attention processors are used
																				for _, module in sd_pipe.unet.named_modules():
																											if isinstance(_SCREAMING_SNAKE_CASE     ,						_SCREAMING_SNAKE_CASE							):
																																		self.assertIsInstance(module.processor     ,						(AttnProcessor, AttnProcessor2_0)							)

            # load LoRA weight file
																				sd_pipe.load_lora_weights(_SCREAMING_SNAKE_CASE							)

																				# check if lora attention processors are used
																				for _, module in sd_pipe.unet.named_modules():
																											if isinstance(_SCREAMING_SNAKE_CASE     ,						_SCREAMING_SNAKE_CASE							):
																																		lowerCamelCase_								=(
																																		    LoRAAttnProcessor2_0 if hasattr(_SCREAMING_SNAKE_CASE     ,						"""scaled_dot_product_attention"""							) else LoRAAttnProcessor
																																		)
																																		self.assertIsInstance(module.processor     ,						_SCREAMING_SNAKE_CASE							)







						@unittest.skipIf(torch_device != """cuda"""     ,						"""This test is supposed to run on GPU"""							)
						def        _snake_case				(			self							)->							Any:
													with tempfile.TemporaryDirectory() as tmpdirname:
																				self.create_lora_weight_file(_SCREAMING_SNAKE_CASE							)

																				lowerCamelCase_	,   lowerCamelCase_								=self.get_dummy_components()
																				lowerCamelCase_								=StableDiffusionPipeline(**_SCREAMING_SNAKE_CASE							)
																				lowerCamelCase_								=sd_pipe.to(_SCREAMING_SNAKE_CASE							)
																				sd_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE							)

																				# enable XFormers
																				sd_pipe.enable_xformers_memory_efficient_attention()

																				# check if xFormers attention processors are used
																				for _, module in sd_pipe.unet.named_modules():
																											if isinstance(_SCREAMING_SNAKE_CASE     ,						_SCREAMING_SNAKE_CASE							):
																																		self.assertIsInstance(module.processor     ,						_SCREAMING_SNAKE_CASE							)

            # load LoRA weight file
																				sd_pipe.load_lora_weights(_SCREAMING_SNAKE_CASE							)

																				# check if lora attention processors are used
																				for _, module in sd_pipe.unet.named_modules():
																											if isinstance(_SCREAMING_SNAKE_CASE     ,						_SCREAMING_SNAKE_CASE							):
																																		self.assertIsInstance(module.processor     ,						_SCREAMING_SNAKE_CASE							)







						@unittest.skipIf(torch_device != """cuda"""     ,						"""This test is supposed to run on GPU"""							)
						def        _snake_case				(			self							)->							int:
													lowerCamelCase_	,   lowerCamelCase_								=self.get_dummy_components()
													lowerCamelCase_								=StableDiffusionPipeline(**_SCREAMING_SNAKE_CASE							)
													lowerCamelCase_								=sd_pipe.to(_SCREAMING_SNAKE_CASE							)
													sd_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE							)

													lowerCamelCase_	,   lowerCamelCase_	,   lowerCamelCase_								=self.get_dummy_inputs()

													# enable XFormers
													sd_pipe.enable_xformers_memory_efficient_attention()

													lowerCamelCase_								=sd_pipe(**_SCREAMING_SNAKE_CASE							).images
													lowerCamelCase_								=original_images[0, -3:, -3:, -1]

													with tempfile.TemporaryDirectory() as tmpdirname:
																				LoraLoaderMixin.save_lora_weights(
																				    save_directory=_SCREAMING_SNAKE_CASE     ,						unet_lora_layers=lora_components["""unet_lora_layers"""]     ,						text_encoder_lora_layers=lora_components["""text_encoder_lora_layers"""]     ,						)
																				self.assertTrue(os.path.isfile(os.path.join(_SCREAMING_SNAKE_CASE     ,						"""pytorch_lora_weights.bin"""							)							)							)
																				sd_pipe.load_lora_weights(_SCREAMING_SNAKE_CASE							)

													lowerCamelCase_								=sd_pipe(**_SCREAMING_SNAKE_CASE							).images
													lowerCamelCase_								=lora_images[0, -3:, -3:, -1]

													# Outputs shouldn't match.
													self.assertFalse(torch.allclose(torch.from_numpy(_SCREAMING_SNAKE_CASE							)     ,						torch.from_numpy(_SCREAMING_SNAKE_CASE							)							)							)



from math import factorial




def        __UpperCamelCase     (      _A					:							Union[str, Any]      ,  _A					:							Tuple		)				->Any:



							"""simple docstring"""
							return factorial(_A		) / (factorial(_A		) * factorial(n - r		))




def        __UpperCamelCase     (      )				->Any:



							"""simple docstring"""
							lowerCamelCase_								=0

							for i in range(1      ,  101		):
														for j in range(1      ,  i + 1		):
																					if combinations(_A      ,  _A		) > 1E6:
																												total += 1
							return total


if __name__ == "__main__":
	print(solution())
