



'''simple docstring'''





from __future__ import annotations

from collections.abc import Iterable, Iterator
from typing import Any, Generic, TypeVar

lowercase_			=  TypeVar("T", bound=bool)






class __A      (  Generic[T]						):



 '''simple docstring'''







 def __init__(self			,       A	)   ->					None:


      """simple docstring"""



      _a     =  value
      _a     =  None
      _a     =  None



 @property
 def  a__  (self	)   ->					T:


      """simple docstring"""



      return self._value



 @staticmethod
 def  a__  (A			,       A	)   ->					SkewNode[T] | None:


      """simple docstring"""



      if not roota:
           return roota

      if not roota:
           return roota

      if roota.value > roota.value:
           _a  ,   _a     =  roota, roota

      _a     =  roota
      _a     =  roota.right
      _a     =  roota.left
      _a     =  SkewNode.merge(A			,       A	)

      return result






class __A      (  Generic[T]						):



 '''simple docstring'''







 def __init__(self			,       A = ()	)   ->					None:


      """simple docstring"""



      _a     =  None
      if data:
           for item in data:
                self.insert(A	)



 def __bool__(self	)   ->					bool:


      """simple docstring"""



      return self._root is not None



 def __iter__(self	)   ->					Iterator[T]:


      """simple docstring"""



      _a     =  []
      while self:
           result.append(self.pop()	)

      # Pushing items back to the heap not to clear it.
      for item in result:
           self.insert(A	)

      return iter(A	)



 def  a__  (self			,       A	)   ->					None:


      """simple docstring"""



      _a     =  SkewNode.merge(self._root			,       SkewNode(A	)	)



 def  a__  (self	)   ->					T | None:


      """simple docstring"""



      _a     =  self.top()
      _a     =  (
          SkewNode.merge(self._root.left			,       self._root.right	) if self._root else None
      )

      return result



 def  a__  (self	)   ->					T:


      """simple docstring"""



      if not self._root:
           raise IndexError('''Can\'t get top element for the empty heap.'''	)
      return self._root.value



 def  a__  (self	)   ->					None:


      """simple docstring"""



      _a     =  None


if __name__ == "__main__":
  import doctest

  doctest.testmod()








'''simple docstring'''





from math import gcd




def lowerCAmelCase  (__A = 12_000):



     """simple docstring"""



     _a     =  0
     for d in range(max_d + 1):
          for n in range(d // 3 + 1  ,     (d + 1) // 2):
               if gcd(__A  ,     __A) == 1:
                    fractions_number += 1
     return fractions_number


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



