'''simple docstring'''

import copy
import re



class 			UpperCAmelCase  :





       '''simple docstring'''



       SCREAMING_SNAKE_CASE							=    "hp"
       SCREAMING_SNAKE_CASE							=    {}
       SCREAMING_SNAKE_CASE							=    None

       @classmethod
       def _lowerCAmelCase(						cls	,   __lowerCAmelCase	,   __lowerCAmelCase )  ->  str:
        lowercase__				:    Dict  =					prefix
        lowercase__				:    str  =					defaults
        cls.build_naming_info()

       @staticmethod
       def _lowerCAmelCase(						__lowerCAmelCase	,   __lowerCAmelCase )  ->  Optional[Any]:
        if len(__lowerCAmelCase ) == 0:
         return ""
        lowercase__				:    List[Any]  =					None
        if any(char.isdigit() for char in word ):
         raise Exception(F"""Parameters should not contain numbers: '{word}' contains a number""" )
        if word in info["short_word"]:
         return info["short_word"][word]
        for prefix_len in range(1	,   len(__lowerCAmelCase ) + 1 ):
         lowercase__				:    Optional[int]  =					word[:prefix_len]
         if prefix in info["reverse_short_word"]:
          continue
         else:
          lowercase__				:    Tuple  =					prefix
          break

        if short_word is None:
         # Paranoid fallback
         def int_to_alphabetic(__lowerCAmelCase ):
          lowercase__				:    Optional[int]  =					''''''
          while integer != 0:
           lowercase__				:    Tuple  =					chr(ord('''A''' ) + integer % 10 ) + s
           integer //= 10
          return s

         lowercase__				:    Optional[Any]  =					0
         while True:
          lowercase__				:    Tuple  =					word + '''#''' + int_to_alphabetic(__lowerCAmelCase )
          if sword in info["reverse_short_word"]:
           continue
          else:
           lowercase__				:    Any  =					sword
           break

        lowercase__				:    Optional[Any]  =					short_word
        lowercase__				:    Dict  =					word
        return short_word

       @staticmethod
       def _lowerCAmelCase(						__lowerCAmelCase	,   __lowerCAmelCase )  ->  Optional[Any]:
        lowercase__				:    Union[str, Any]  =					param_name.split('''_''' )

        lowercase__				:    Optional[int]  =					[TrialShortNamer.shortname_for_word(__lowerCAmelCase	,   __lowerCAmelCase ) for word in words]

        # We try to create a separatorless short name, but if there is a collision we have to fallback
        # to a separated short name
        lowercase__				:    List[str]  =					['''''', '''_''']

        for separator in separators:
         lowercase__				:    int  =					separator.join(__lowerCAmelCase )
         if shortname not in info["reverse_short_param"]:
          lowercase__				:    int  =					shortname
          lowercase__				:    List[Any]  =					param_name
          return shortname

        return param_name

       @staticmethod
       def _lowerCAmelCase(						__lowerCAmelCase	,   __lowerCAmelCase )  ->  int:
        lowercase__				:    Dict  =					TrialShortNamer.shortname_for_key(__lowerCAmelCase	,   __lowerCAmelCase )
        lowercase__				:    Optional[int]  =					short_name
        lowercase__				:    str  =					param_name

       @classmethod
       def _lowerCAmelCase(						cls )  ->  Any:
        if cls.NAMING_INFO is not None:
         return

        lowercase__				:    int  =					{
            '''short_word''': {},
            '''reverse_short_word''': {},
            '''short_param''': {},
            '''reverse_short_param''': {},
        }

        lowercase__				:    Any  =					list(cls.DEFAULTS.keys() )

        for k in field_keys:
         cls.add_new_param_name(__lowerCAmelCase	,   __lowerCAmelCase )

        lowercase__				:    str  =					info

       @classmethod
       def _lowerCAmelCase(						cls	,   __lowerCAmelCase )  ->  str:
        cls.build_naming_info()
        assert cls.PREFIX is not None
        lowercase__				:    Union[str, Any]  =					[copy.copy(cls.PREFIX )]

        for k, v in params.items():
         if k not in cls.DEFAULTS:
          raise Exception(F"""You should provide a default value for the param name {k} with value {v}""" )
         if v == cls.DEFAULTS[k]:
          # The default value is not added to the name
          continue

         lowercase__				:    Optional[int]  =					cls.NAMING_INFO['''short_param'''][k]

         if isinstance(__lowerCAmelCase	,   __lowerCAmelCase ):
          lowercase__				:    List[Any]  =					1 if v else 0

         lowercase__				:    Optional[int]  =					'''''' if isinstance(__lowerCAmelCase	,   (int, float) ) else '''-'''
         lowercase__				:    Optional[Any]  =					F"""{key}{sep}{v}"""
         name.append(__lowerCAmelCase )

        return "_".join(__lowerCAmelCase )


       @classmethod
       def _lowerCAmelCase(						cls	,   __lowerCAmelCase )  ->  Any:
        lowercase__				:    Dict  =					repr[len(cls.PREFIX ) + 1 :]
        if repr == "":
         lowercase__				:    List[str]  =					[]
        else:
         lowercase__				:    List[str]  =					repr.split('''_''' )

        lowercase__				:    int  =					{}

        for value in values:
         if "-" in value:
          lowercase__ ,							lowercase__				:    str  =					value.split('''-''' )
         else:
          lowercase__				:    List[str]  =					re.sub('''[0-9.]'''	,   ''''''	,   __lowerCAmelCase )
          lowercase__				:    Tuple  =					float(re.sub('''[^0-9.]'''	,   ''''''	,   __lowerCAmelCase ) )

         lowercase__				:    int  =					cls.NAMING_INFO['''reverse_short_param'''][p_k]

         lowercase__				:    int  =					p_v

        for k in cls.DEFAULTS:
         if k not in parameters:
          lowercase__				:    Optional[Any]  =					cls.DEFAULTS[k]

        return parameters


'''simple docstring'''

def 			__UpperCamelCase       (   UpperCAmelCase     ):
 lowercase__				:    List[str]  =					0
 while num > 0:
  digit_sum += num % 10
  num //= 10
 return digit_sum
def 			__UpperCamelCase       (   UpperCAmelCase = 100     ):
 lowercase__				:    Dict  =					1
 lowercase__				:    Optional[int]  =					2

 for i in range(2		,     max_n + 1     ):
  lowercase__				:    List[str]  =					pre_numerator
  lowercase__				:    Optional[Any]  =					2 * i // 3 if i % 3 == 0 else 1
  lowercase__				:    Union[str, Any]  =					cur_numerator
  lowercase__				:    int  =					e_cont * pre_numerator + temp

 return sum_digits(UpperCAmelCase     )


if __name__ == "__main__":
  print(F'{solution() = }')

