



"""simple docstring"""







import random
import unittest

import torch

from diffusers import IFSuperResolutionPipeline
from diffusers.utils import floats_tensor
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import skip_mps, torch_device

from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin
from . import IFPipelineTesterMixin

@skip_mps
class       UpperCamelCase  (					a      , a      , unittest.TestCase				):





     """simple docstring"""






     _lowerCamelCase					: Union[str, Any]				   =IFSuperResolutionPipeline
     _lowerCamelCase					: int				   =TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"width", "height"}
     _lowerCamelCase					: List[str]				   =TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
     _lowerCamelCase					: List[str]				   =PipelineTesterMixin.required_optional_params - {"latents"}





     def 						A__  (					self :							str ):
          return self._get_superresolution_dummy_components()





     def 						A__  (					self :							Any	,      _lowerCamelCase :							Tuple	,      _lowerCamelCase :							Optional[int]=0 ):
          if str(_lowerCamelCase ).startswith('''mps''' ):
               A__				=   torch.manual_seed(_lowerCamelCase )
          else:
               A__				=   torch.Generator(device=_lowerCamelCase ).manual_seed(_lowerCamelCase )

          A__				=   floats_tensor((1, 3, 3_2, 3_2)	,      rng=random.Random(_lowerCamelCase ) ).to(_lowerCamelCase )

          A__				=   {
              '''prompt''': '''A painting of a squirrel eating a burger''',
              '''image''': image,
              '''generator''': generator,
              '''num_inference_steps''': 2,
              '''output_type''': '''numpy''',
          }

          return inputs





     @unittest.skipIf(
         torch_device != '''cuda''' or not is_xformers_available()	,      reason='''XFormers attention is only available with CUDA and `xformers` installed'''	,      )
     def 						A__  (					self :							str ):
          self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3 )





     def 						A__  (					self :							Tuple ):
          self._test_save_load_optional_components()





     @unittest.skipIf(torch_device != '''cuda'''	,      reason='''float16 requires CUDA''' )
     def 						A__  (					self :							Dict ):
          # Due to non-determinism in save load of the hf-internal-testing/tiny-random-t5 text encoder
          super().test_save_load_floataa(expected_max_diff=1E-1 )





     def 						A__  (					self :							Any ):
          self._test_attention_slicing_forward_pass(expected_max_diff=1E-2 )





     def 						A__  (					self :							int ):
          self._test_save_load_local()





     def 						A__  (					self :							Optional[Any] ):
          self._test_inference_batch_single_identical(
              expected_max_diff=1E-2	,      )










"""simple docstring"""







from math import factorial



def   a_	(			__a		,							__a      ):
     return factorial(__a      ) / (factorial(__a      ) * factorial(n - r      ))



def   a_	(			):
     A__				=   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())



