'''simple docstring'''




from math import isqrt, loga

def _lowercase						(   lowerCamelCase__    )       ->							Optional[int]:





       """simple docstring"""


       __UpperCAmelCase	:					List[str]												=		[True] * max_number
       for i in range(2				,     isqrt(max_number - 1    ) + 1    ):
              if is_prime[i]:
                     for j in range(i**2				,     __snake_case				,     __snake_case    ):
                            __UpperCAmelCase	:					Optional[int]												=		False

       return [i for i in range(2				,     __snake_case    ) if is_prime[i]]

def _lowercase						(   lowerCamelCase__ = 80_0800				,     lowerCamelCase__ = 80_0800    )       ->							int:





       """simple docstring"""


       __UpperCAmelCase	:					Union[str, Any]												=		degree * loga(__snake_case    )
       __UpperCAmelCase	:					Union[str, Any]												=		int(__snake_case    )
       __UpperCAmelCase	:					Dict												=		calculate_prime_numbers(__snake_case    )

       __UpperCAmelCase	:					Optional[int]												=		0
       __UpperCAmelCase	:					Any												=		0
       __UpperCAmelCase	:					Any												=		len(__snake_case    ) - 1
       while left < right:
              while (
                  prime_numbers[right] * loga(prime_numbers[left]    )
                  + prime_numbers[left] * loga(prime_numbers[right]    )
                  > upper_bound
              ):
                     right -= 1
              hybrid_integers_count += right - left
              left += 1

       return hybrid_integers_count


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










"""simple docstring"""
def 				_snake_case      (   __snake_case							:      list[list[int]]						, __snake_case							:      int						, __snake_case							:      int						, __snake_case							:      list[int]   ):




   """simple docstring"""







   if graph[path[curr_ind - 1]][next_ver] == 0:
      return False

   # 2. Validate that next vertex is not already in path
   return not any(vertex == next_ver for vertex in path   )

def 				_snake_case      (   __snake_case							:      list[list[int]]						, __snake_case							:      list[int]						, __snake_case							:      int   ):




   """simple docstring"""







   if curr_ind == len(__snake_case   ):
      # return whether path exists between current and starting vertices
      return graph[path[curr_ind - 1]][path[0]] == 1

   # Recursive Step
   for next_ver in range(0						, len(__snake_case   )   ):
      if valid_connection(__snake_case						, __snake_case						, __snake_case						, __snake_case   ):
         # Insert current vertex  into path as next transition
         _lowerCamelCase	:					List[str]   =		next_ver
         # Validate created path
         if util_hamilton_cycle(__snake_case						, __snake_case						, curr_ind + 1   ):
            return True
         # Backtrack
         _lowerCamelCase	:					Tuple   =		-1
   return False





def 				_snake_case      (   __snake_case							:      list[list[int]]						, __snake_case							:      int = 0   ):




   """simple docstring"""







   _lowerCamelCase	:					Any   =		[-1] * (len(__snake_case   ) + 1)
   # initialize start and end of path with starting index
   _lowerCamelCase	:					Optional[int]   =		start_index
   # evaluate and if we find answer return path either return empty array
   return path if util_hamilton_cycle(__snake_case						, __snake_case						, 1   ) else []

