




import gc
import unittest

from parameterized import parameterized

from diffusers import FlaxUNetaDConditionModel
from diffusers.utils import is_flax_available
from diffusers.utils.testing_utils import load_hf_numpy, require_flax, slow


if is_flax_available():
     import jax
     import jax.numpy as jnp

@slow
@require_flax
class   __a(					unittest.TestCase       ):






    """simple docstring"""





    def 							a__				(				self       ,_SCREAMING_SNAKE_CASE       ,_SCREAMING_SNAKE_CASE  )			->		Tuple:
      return f'''gaussian_noise_s={seed}_shape={"_".join([str(lowerCamelCase_  ) for s in shape]  )}.npy'''





    def 							a__				(				self  )			->		List[Any]:
      # clean up the VRAM after each test
      super().tearDown()
      gc.collect()





    def 							a__				(				self       ,_SCREAMING_SNAKE_CASE=0       ,_SCREAMING_SNAKE_CASE=(4, 4, 64, 64)       ,_SCREAMING_SNAKE_CASE=False  )			->		List[str]:
      UpperCAmelCase_      :							Optional[Any]       =      jnp.bfloataa if fpaa else jnp.floataa
      UpperCAmelCase_      :							List[str]       =      jnp.array(load_hf_numpy(self.get_file_format(lowerCamelCase_       ,lowerCamelCase_  )  )       ,dtype=lowerCamelCase_  )
      return image





    def 							a__				(				self       ,_SCREAMING_SNAKE_CASE=False       ,_SCREAMING_SNAKE_CASE="CompVis/stable-diffusion-v1-4"  )			->		Union[str, Any]:
      UpperCAmelCase_      :							int       =      jnp.bfloataa if fpaa else jnp.floataa
      UpperCAmelCase_      :							Optional[Any]       =      """bf16""" if fpaa else None

      UpperCAmelCase_      :							Any       =      FlaxUNetaDConditionModel.from_pretrained(
          lowerCamelCase_       ,subfolder='''unet'''       ,dtype=lowerCamelCase_       ,revision=lowerCamelCase_  )
      return model, params





    def 							a__				(				self       ,_SCREAMING_SNAKE_CASE=0       ,_SCREAMING_SNAKE_CASE=(4, 77, 768)       ,_SCREAMING_SNAKE_CASE=False  )			->		Union[str, Any]:
      UpperCAmelCase_      :							Union[str, Any]       =      jnp.bfloataa if fpaa else jnp.floataa
      UpperCAmelCase_      :							Any       =      jnp.array(load_hf_numpy(self.get_file_format(lowerCamelCase_       ,lowerCamelCase_  )  )       ,dtype=lowerCamelCase_  )
      return hidden_states





    @parameterized.expand(
        [
            # fmt: off
            [83, 4, [-0.23_23, -0.13_04, 0.08_13, -0.30_93, -0.09_19, -0.15_71, -0.11_25, -0.58_06]],
            [17, 0.55, [-0.08_31, -0.24_43, 0.09_01, -0.09_19, 0.33_96, 0.01_03, -0.37_43, 0.07_01]],
            [8, 0.89, [-0.48_63, 0.08_59, 0.08_75, -0.16_58, 0.91_99, -0.01_14, 0.48_39, 0.46_39]],
            [3, 1_000, [-0.56_49, 0.24_02, -0.55_18, 0.12_48, 1.13_28, -0.24_43, -0.03_25, -1.00_78]],
            # fmt: on
        ]  )
    def 							a__				(				self       ,_SCREAMING_SNAKE_CASE       ,_SCREAMING_SNAKE_CASE       ,_SCREAMING_SNAKE_CASE  )			->		Union[str, Any]:
      UpperCAmelCase_      :							List[str]       =      self.get_unet_model(model_id='''CompVis/stable-diffusion-v1-4'''       ,fpaa=lowerCamelCase_  )
      UpperCAmelCase_      :							Tuple       =      self.get_latents(lowerCamelCase_       ,fpaa=lowerCamelCase_  )
      UpperCAmelCase_      :							Union[str, Any]       =      self.get_encoder_hidden_states(lowerCamelCase_       ,fpaa=lowerCamelCase_  )

      UpperCAmelCase_      :							int       =      model.apply(
          {'''params''': params}       ,lowerCamelCase_       ,jnp.array(lowerCamelCase_       ,dtype=jnp.intaa  )       ,encoder_hidden_states=lowerCamelCase_       ,).sample

      assert sample.shape == latents.shape

      UpperCAmelCase_      :							Any       =      jnp.asarray(jax.device_get((sample[-1, -2:, -2:, :2].flatten())  )       ,dtype=jnp.floataa  )
      UpperCAmelCase_      :							Dict       =      jnp.array(lowerCamelCase_       ,dtype=jnp.floataa  )

      # Found torch (float16) and flax (bfloat16) outputs to be within this tolerance, in the same hardware
      assert jnp.allclose(lowerCamelCase_       ,lowerCamelCase_       ,atol=1e-2  )





    @parameterized.expand(
        [
            # fmt: off
            [83, 4, [0.15_14, 0.08_07, 0.16_24, 0.10_16, -0.18_96, 0.02_63, 0.06_77, 0.23_10]],
            [17, 0.55, [0.11_64, -0.02_16, 0.01_70, 0.15_89, -0.31_20, 0.10_05, -0.05_81, -0.14_58]],
            [8, 0.89, [-0.17_58, -0.01_69, 0.10_04, -0.14_11, 0.13_12, 0.11_03, -0.19_96, 0.21_39]],
            [3, 1_000, [0.12_14, 0.03_52, -0.07_31, -0.15_62, -0.09_94, -0.09_06, -0.23_40, -0.05_39]],
            # fmt: on
        ]  )
    def 							a__				(				self       ,_SCREAMING_SNAKE_CASE       ,_SCREAMING_SNAKE_CASE       ,_SCREAMING_SNAKE_CASE  )			->		Union[str, Any]:
      UpperCAmelCase_      :							int       =      self.get_unet_model(model_id='''stabilityai/stable-diffusion-2'''       ,fpaa=lowerCamelCase_  )
      UpperCAmelCase_      :							List[Any]       =      self.get_latents(lowerCamelCase_       ,shape=(4, 4, 96, 96)       ,fpaa=lowerCamelCase_  )
      UpperCAmelCase_      :							Dict       =      self.get_encoder_hidden_states(lowerCamelCase_       ,shape=(4, 77, 1_024)       ,fpaa=lowerCamelCase_  )

      UpperCAmelCase_      :							List[Any]       =      model.apply(
          {'''params''': params}       ,lowerCamelCase_       ,jnp.array(lowerCamelCase_       ,dtype=jnp.intaa  )       ,encoder_hidden_states=lowerCamelCase_       ,).sample

      assert sample.shape == latents.shape

      UpperCAmelCase_      :							List[str]       =      jnp.asarray(jax.device_get((sample[-1, -2:, -2:, :2].flatten())  )       ,dtype=jnp.floataa  )
      UpperCAmelCase_      :							Dict       =      jnp.array(lowerCamelCase_       ,dtype=jnp.floataa  )

      # Found torch (float16) and flax (bfloat16) outputs to be within this tolerance, on the same hardware
      assert jnp.allclose(lowerCamelCase_       ,lowerCamelCase_       ,atol=1e-2  )





from __future__ import annotations

from fractions import Fraction







def lowerCamelCase__       (      _lowercase			,						_lowercase				):

     '''simple docstring'''


     return (
         num != den and num % 10 == den // 10 and (num // 10) / (den % 10) == num / den
     )







def lowerCamelCase__       (      _lowercase				):

     '''simple docstring'''


     UpperCAmelCase_      :							Optional[int]       =      []
     UpperCAmelCase_      :							Tuple       =      11
     UpperCAmelCase_      :							int       =      int('''1''' + '''0''' * digit_len				)
     for num in range(_lowercase			,						_lowercase				):
          while den <= 99:
               if (num != den) and (num % 10 == den // 10) and (den % 10 != 0):
                    if is_digit_cancelling(_lowercase			,						_lowercase				):
                         solutions.append(f'''{num}/{den}'''				)
               den += 1
          num += 1
          UpperCAmelCase_      :							Any       =      10
     return solutions







def lowerCamelCase__       (      _lowercase = 2				):

     '''simple docstring'''


     UpperCAmelCase_      :							Tuple       =      1.0
     for fraction in fraction_list(_lowercase				):
          UpperCAmelCase_      :							Optional[Any]       =      Fraction(_lowercase				)
          result *= frac.denominator / frac.numerator
     return int(_lowercase				)


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