
"""simple docstring"""
class   _UpperCAmelCase					:






    class   _UpperCAmelCase					:
        __lowercase				:			List[Any]	=       """_prev""", """_data""", """_next"""
        def __init__(     self    ,     snake_case_    ,     snake_case_    ,     snake_case_  ):
          _snake_case  :    List[str]            = link_p
          _snake_case  :    List[str]            = element
          _snake_case  :    str            = link_n


        def        lowerCamelCase__						(     self  ):
          return (
              F' Prev -> {self._prev is not None}, Next -> {self._next is not None}'
          )


    def __init__(     self  ):
      _snake_case  :    List[Any]            = self._Node(a__    ,     a__    ,     a__  )
      _snake_case  :    Optional[Any]            = self._Node(a__    ,     a__    ,     a__  )
      _snake_case  :    Optional[Any]            = self._trailer
      _snake_case  :    Tuple            = self._header
      _snake_case  :    Any            = 0
    def __len__(     self  ):
      return self._size
    def        lowerCamelCase__						(     self  ):
      return self.__len__() == 0
    def        lowerCamelCase__						(     self    ,     snake_case_    ,     snake_case_    ,     snake_case_  ):
      _snake_case  :    Any            = self._Node(a__    ,     a__    ,     a__  )
      _snake_case  :    Union[str, Any]            = new_node
      _snake_case  :    int            = new_node
      self._size += 1
      return self


    def        lowerCamelCase__						(     self    ,     snake_case_  ):
      _snake_case  :    Optional[Any]            = node._prev
      _snake_case  :    Any            = node._next

      _snake_case  :    Dict            = successor
      _snake_case  :    Tuple            = predecessor
      self._size -= 1
      _snake_case  :    Any            = node._data
      _snake_case  :    List[Any]            = None
      del node
      return temp






class   _UpperCAmelCase					(       _DoublyLinkedBase):
    def        lowerCamelCase__						(     self  ):







      if self.is_empty():
        raise Exception("List is empty"  )
      return self._header._next._data
    def        lowerCamelCase__						(     self  ):







      if self.is_empty():
        raise Exception("List is empty"  )
      return self._trailer._prev._data
    def        lowerCamelCase__						(     self    ,     snake_case_  ):
      return self._insert(self._header    ,     a__    ,     self._header._next  )
    def        lowerCamelCase__						(     self    ,     snake_case_  ):
      return self._insert(self._trailer._prev    ,     a__    ,     self._trailer  )
    def        lowerCamelCase__						(     self  ):







      if self.is_empty():
        raise IndexError("remove_first from empty list"  )
      return self._delete(self._header._next  )


    def        lowerCamelCase__						(     self  ):







      if self.is_empty():
        raise IndexError("remove_first from empty list"  )
      return self._delete(self._trailer._prev  )





"""simple docstring"""


from math import factorial






def   a__			(					__lowercase  ,      __lowercase )						->						List[Any]:
				return factorial(__lowercase ) / (factorial(__lowercase ) * factorial(n - r ))






def   a__			(					)						->						List[str]:
				_A       	=      0

				for i in range(1  ,      101 ):
								for j in range(1  ,      i + 1 ):
												if combinations(__lowercase  ,      __lowercase ) > 1E6:
																total += 1
				return total


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