


"""simple docstring"""



from math import factorial

UpperCAmelCase      		=			{str(digit): factorial(digit) for digit in range(10)}






def       lowerCamelCase					(a_						:List[str])     ->							int:
							if not isinstance(a_				,				a_):
														raise TypeError('''Parameter number must be int''')

							if number < 0:
														raise ValueError('''Parameter number must be greater than or equal to 0''')

							# Converts number in string to iterate on its digits and adds its factorial.
							return sum(DIGIT_FACTORIAL[digit] for digit in str(a_))






def       lowerCamelCase					(a_						:List[Any] = 60				,				a_						:Optional[Any] = 100_0000)     ->							int:

							if not isinstance(a_				,				a_) or not isinstance(a_				,				a_):
														raise TypeError('''Parameters chain_length and number_limit must be int''')

							if chain_length <= 0 or number_limit <= 0:
														raise ValueError(
														    '''Parameters chain_length and number_limit must be greater than 0''')

							# the counter for the chains with the exact desired length
							lowercase		:List[Any]       							=				0
							# the cached sizes of the previous chains
							lowercase		:int       							=				{}

							for start_chain_element in range(1				,				a_):
														# The temporary set will contain the elements of the chain
														lowercase		:str       							=				set()
														lowercase		:Union[str, Any]       							=				0

														# Stop computing the chain when you find a cached size, a repeating item or the
														# length is greater then the desired one.
														lowercase		:str       							=				start_chain_element
														while (
														    chain_element not in chain_sets_lengths
														    and chain_element not in chain_set
														    and chain_set_length <= chain_length
														):
																					chain_set.add(a_)
																					chain_set_length += 1
																					lowercase		:Tuple       							=				digit_factorial_sum(a_)

														if chain_element in chain_sets_lengths:
																					chain_set_length += chain_sets_lengths[chain_element]

														lowercase		:List[str]       							=				chain_set_length

														# If chain contains the exact amount of elements increase the counter
														if chain_set_length == chain_length:
																					chains_counter += 1

							return chains_counter


if __name__ == "__main__":
	import doctest

	doctest.testmod()
	print(F"""{solution()}""")





"""simple docstring"""



import unittest

from diffusers import FlaxAutoencoderKL
from diffusers.utils import is_flax_available
from diffusers.utils.testing_utils import require_flax

from .test_modeling_common_flax import FlaxModelTesterMixin


if is_flax_available():
 import jax
@require_flax
class 					__magic_name__		(			__UpperCAmelCase			,						unittest.TestCase     ):
       __A			:      str        =   FlaxAutoencoderKL






       @property
       def  __snake_case						(   self  :    List[str]				):

              '''simple docstring'''






              lowercase		:Dict       							=				4
              lowercase		:Optional[int]       							=				3
              lowercase		:Any       							=				(3_2, 3_2)

              lowercase		:Optional[int]       							=				jax.random.PRNGKey(0				)
              lowercase		:Any       							=				jax.random.uniform(snake_case__  ,     ((batch_size, num_channels) + sizes)				)

              return {"sample": image, "prng_key": prng_key}







       def  __snake_case						(   self  :    Union[str, Any]				):

              '''simple docstring'''






              lowercase		:List[Any]       							=				{
                  '''block_out_channels''': [3_2, 6_4],
                  '''in_channels''': 3,
                  '''out_channels''': 3,
                  '''down_block_types''': ['''DownEncoderBlock2D''', '''DownEncoderBlock2D'''],
                  '''up_block_types''': ['''UpDecoderBlock2D''', '''UpDecoderBlock2D'''],
                  '''latent_channels''': 4,
              }
              lowercase		:Optional[int]       							=				self.dummy_input
              return init_dict, inputs_dict

