


'''simple docstring'''




from math import factorial

_a   :   dict[str, int]												=   {str(digit): factorial(digit) for digit in range(10)}





def   _a		(lowercase__			:   int						)			->			int:






     """simple docstring"""
     if not isinstance(lowercase__							,   lowercase__						):
          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(lowercase__						)						)





def   _a		(lowercase__			:   int = 6_0							,   lowercase__			:   int = 1_0_0_0_0_0_0						)			->			int:






     """simple docstring"""

     if not isinstance(lowercase__							,   lowercase__						) or not isinstance(lowercase__							,   lowercase__						):
          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
     __snake_case           =						0
     # the cached sizes of the previous chains
     __snake_case           =						{}

     for start_chain_element in range(1							,   lowercase__						):
          # The temporary set will contain the elements of the chain
          __snake_case           =						set()
          __snake_case           =						0

          # Stop computing the chain when you find a cached size, a repeating item or the
          # length is greater then the desired one.
          __snake_case           =						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(lowercase__						)
               chain_set_length += 1
               __snake_case           =						digit_factorial_sum(lowercase__						)

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

          __snake_case           =						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()}''')









import requests
from bsa import BeautifulSoup






def     __a					(		__UpperCAmelCase							,  __UpperCAmelCase       ):
 a__												= BeautifulSoup(requests.get(__UpperCAmelCase							,  params=__UpperCAmelCase       ).content							,  '''html.parser'''       )
 a__												= soup.find('''div'''							,  attrs={'''class''': '''gs_ri'''}       )
 a__												= div.find('''div'''							,  attrs={'''class''': '''gs_fl'''}       ).find_all('''a'''       )
 return anchors[2].get_text()


if __name__ == "__main__":
     a_      :      Optional[Any]    =     {
         'title': (
             'Precisely geometry controlled microsupercapacitors for ultrahigh areal '
             'capacitance, volumetric capacitance, and energy density'
         ),
         'journal': 'Chem. Mater.',
         'volume': 30,
         'pages': '3979-3990',
         'year': 20_18,
         'hl': 'en',
     }
     print(get_citation('https://scholar.google.com/scholar_lookup', params=params))





