


from __future__ import annotations

from typing import Any


class 	a__						:

       def __init__( self   :  Any   ,				lowerCamelCase_   :  Any   ,				lowerCamelCase_   :  Any     ):  # noqa: A002
            a_     :  Dict				      =     item
            a_     :  List[Any]				      =     next


class 	a__						:

       def __init__( self   :  Optional[Any]     ):
            a_     :  Node | None				      =     None
            a_     :  Optional[int]				      =     0

       def     UpperCAmelCase( self   :  List[str]   ,				lowerCamelCase_   :  Any     ):
            a_     :  Optional[int]				      =     Node(lowerCamelCase_   ,				self.head     )
            self.size += 1

       def     UpperCAmelCase( self   :  List[str]     ):
            # Switched 'self.is_empty()' to 'self.head is None'
            # because mypy was considering the possibility that 'self.head'
            # can be None in below else part and giving error
            if self.head is None:
                 return None
            else:
                 a_     :  Tuple				      =     self.head.item
                 a_     :  int				      =     self.head.next
                 self.size -= 1
                 return item

       def     UpperCAmelCase( self   :  str     ):
            return self.head is None

       def __str__( self   :  Tuple     ):
            if self.is_empty():
                 return ""
            else:
                 a_     :  Optional[Any]				      =     self.head
                 a_     :  List[Any]				      =     """"""
                 a_     :  list[str]				      =     []
                 while iterate:
                      item_list.append(str(iterate.item     )     )
                      a_     :  Optional[int]				      =     iterate.next

                 a_     :  Optional[Any]				      =     """ --> """.join(lowerCamelCase_     )

                 return item_str

       def __len__( self   :  Tuple     ):
            return self.size







def 	_lowerCamelCase  (		A_  :	float							,  A_  :	float							,  A_  :	int      )			->			float:

   '''simple docstring'''






   UpperCamelCase__ :			Union[str, Any] 						=[1 / first_term]
   UpperCamelCase__ :			Tuple 						=1 / first_term
   for _ in range(number_of_terms - 1      ):
      first_term += common_difference
      arithmetic_progression.append(A_      )
   UpperCamelCase__ :			List[str] 						=[1 / step for step in arithmetic_progression]
   return sum(A_      )


if __name__ == "__main__":
     import doctest

     doctest.testmod()
     print(sum_of_harmonic_progression(1 / 2, 2, 2))

